From 6b7930104bdb845d3b9c085dc04f52b6446f23b1 Mon Sep 17 00:00:00 2001 From: lbsa71 Date: Tue, 24 Jun 2008 21:09:49 +0000 Subject: * Applied patch from Melanie, mantis issue #1581 - "Refactor LSL language, api and compiler out of XEngine" "First stage in a major Script Engine refactor, that will result in the LSL implementaions ebing reconverged. Not there yet, but one major part is done." Thank you, Melanie! --- .../Region/ScriptEngine/Interfaces/ICompiler.cs | 39 + OpenSim/Region/ScriptEngine/Interfaces/IScript.cs | 17 + .../Region/ScriptEngine/Interfaces/IScriptApi.cs | 43 + .../ScriptEngine/Interfaces/IScriptEngine.cs | 59 + .../Shared/Api/Implementation/ApiManager.cs | 79 + .../Api/Implementation/AsyncCommandManager.cs | 308 + .../Shared/Api/Implementation/LSL_Api.cs | 6583 +++++++++++++++++++ .../Shared/Api/Implementation/OSSL_Api.cs | 553 ++ .../Api/Implementation/Plugins/Dataserver.cs | 128 + .../Api/Implementation/Plugins/HttpRequest.cs | 91 + .../Shared/Api/Implementation/Plugins/Listener.cs | 92 + .../Api/Implementation/Plugins/SensorRepeat.cs | 389 ++ .../Shared/Api/Implementation/Plugins/Timer.cs | 162 + .../Api/Implementation/Plugins/XmlRequest.cs | 117 + .../ScriptEngine/Shared/Api/Interface/ILSL_Api.cs | 649 ++ .../ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs | 68 + .../Shared/Api/Runtime/LSL_Constants.cs | 421 ++ .../ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs | 1732 +++++ .../ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs | 199 + ...m.Region.ScriptEngine.Shared.Api.Runtime.csproj | 161 + ...ion.ScriptEngine.Shared.Api.Runtime.csproj.user | 12 + ...egion.ScriptEngine.Shared.Api.Runtime.dll.build | 62 + ...nSim.Region.ScriptEngine.Shared.Api.Runtime.mdp | 43 + .../ScriptEngine/Shared/Api/Runtime/ScriptBase.cs | 124 + .../Shared/Api/Runtime/YieldProlog/Atom.cs | 218 + .../Shared/Api/Runtime/YieldProlog/BagofAnswers.cs | 234 + .../Api/Runtime/YieldProlog/FindallAnswers.cs | 103 + .../Shared/Api/Runtime/YieldProlog/Functor.cs | 188 + .../Shared/Api/Runtime/YieldProlog/Functor1.cs | 111 + .../Shared/Api/Runtime/YieldProlog/Functor2.cs | 154 + .../Shared/Api/Runtime/YieldProlog/Functor3.cs | 133 + .../Api/Runtime/YieldProlog/IndexedAnswers.cs | 288 + .../Shared/Api/Runtime/YieldProlog/ListPair.cs | 156 + .../Shared/Api/Runtime/YieldProlog/Parser.cs | 4457 +++++++++++++ .../Api/Runtime/YieldProlog/PrologException.cs | 71 + .../YieldProlog/UndefinedPredicateException.cs | 62 + .../Shared/Api/Runtime/YieldProlog/Variable.cs | 196 + .../Shared/Api/Runtime/YieldProlog/YP.cs | 1644 +++++ .../Shared/Api/Runtime/YieldProlog/YPCompiler.cs | 5651 +++++++++++++++++ .../Region/ScriptEngine/Shared/AssemblyResolver.cs | 65 + .../ScriptEngine/Shared/CodeTools/Compiler.cs | 515 ++ .../Shared/CodeTools/LSL2CSConverter.cs | 374 ++ .../Shared/CodeTools/YP2CSConverter.cs | 108 + OpenSim/Region/ScriptEngine/Shared/Helpers.cs | 121 + OpenSim/Region/ScriptEngine/Shared/LSL_Types.cs | 1519 +++++ .../ScriptEngine/XEngine/AsyncCommandManager.cs | 268 - .../XEngine/AsyncCommandPlugins/Dataserver.cs | 127 - .../XEngine/AsyncCommandPlugins/Eventstream.cs | 75 - .../XEngine/AsyncCommandPlugins/HttpRequest.cs | 89 - .../XEngine/AsyncCommandPlugins/Listener.cs | 91 - .../XEngine/AsyncCommandPlugins/SensorRepeat.cs | 393 -- .../XEngine/AsyncCommandPlugins/Timer.cs | 161 - .../XEngine/AsyncCommandPlugins/XmlRequest.cs | 115 - OpenSim/Region/ScriptEngine/XEngine/Compiler.cs | 515 -- .../Region/ScriptEngine/XEngine/EventManager.cs | 99 +- OpenSim/Region/ScriptEngine/XEngine/Executor.cs | 19 +- .../Region/ScriptEngine/XEngine/ExecutorBase.cs | 16 +- .../Region/ScriptEngine/XEngine/LSL2CSConverter.cs | 374 -- .../ScriptEngine/XEngine/LSL_ScriptCommands.cs | 6593 -------------------- .../ScriptEngine/XEngine/OSSL_ScriptCommands.cs | 553 -- .../XEngine/Script/AssemblyResolver.cs | 65 - .../XEngine/Script/BuiltIn_Commands_BaseClass.cs | 2397 ------- .../XEngine/Script/ILSL_ScriptCommands.cs | 653 -- .../XEngine/Script/IOSSL_ScriptCommands.cs | 68 - .../Region/ScriptEngine/XEngine/Script/IScript.cs | 46 - .../ScriptEngine/XEngine/Script/LSL_Types.cs | 1512 ----- OpenSim/Region/ScriptEngine/XEngine/XEngine.cs | 234 +- 67 files changed, 28645 insertions(+), 14317 deletions(-) create mode 100644 OpenSim/Region/ScriptEngine/Interfaces/ICompiler.cs create mode 100644 OpenSim/Region/ScriptEngine/Interfaces/IScript.cs create mode 100644 OpenSim/Region/ScriptEngine/Interfaces/IScriptApi.cs create mode 100644 OpenSim/Region/ScriptEngine/Interfaces/IScriptEngine.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Implementation/ApiManager.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Implementation/AsyncCommandManager.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Dataserver.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/HttpRequest.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Listener.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Timer.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/XmlRequest.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj.user create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.dll.build create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.mdp create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Atom.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/BagofAnswers.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/FindallAnswers.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor1.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor2.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor3.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/IndexedAnswers.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/ListPair.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/PrologException.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/UndefinedPredicateException.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Variable.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YP.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YPCompiler.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/AssemblyResolver.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/CodeTools/LSL2CSConverter.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/CodeTools/YP2CSConverter.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/Helpers.cs create mode 100644 OpenSim/Region/ScriptEngine/Shared/LSL_Types.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandManager.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Dataserver.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Eventstream.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/HttpRequest.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Listener.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/SensorRepeat.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Timer.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/XmlRequest.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/Compiler.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/LSL2CSConverter.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/LSL_ScriptCommands.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/OSSL_ScriptCommands.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/Script/AssemblyResolver.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/Script/BuiltIn_Commands_BaseClass.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/Script/ILSL_ScriptCommands.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/Script/IOSSL_ScriptCommands.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/Script/IScript.cs delete mode 100644 OpenSim/Region/ScriptEngine/XEngine/Script/LSL_Types.cs (limited to 'OpenSim') diff --git a/OpenSim/Region/ScriptEngine/Interfaces/ICompiler.cs b/OpenSim/Region/ScriptEngine/Interfaces/ICompiler.cs new file mode 100644 index 0000000..efb05d3 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Interfaces/ICompiler.cs @@ -0,0 +1,39 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections.Generic; +using Nini.Config; + +namespace OpenSim.Region.ScriptEngine.Interfaces +{ + public interface ICompiler + { + void Configure(IConfig configSource); + void Compile(string text, string outFile, List apiList); + } +} diff --git a/OpenSim/Region/ScriptEngine/Interfaces/IScript.cs b/OpenSim/Region/ScriptEngine/Interfaces/IScript.cs new file mode 100644 index 0000000..553d56d --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Interfaces/IScript.cs @@ -0,0 +1,17 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using OpenSim.Region.ScriptEngine.Interfaces; + +namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase +{ + public interface IScript + { + string[] GetApis(); + void InitApi(string name, IScriptApi data); + + Dictionary GetVars(); + void SetVars(Dictionary vars); + void ResetVars(); + } +} diff --git a/OpenSim/Region/ScriptEngine/Interfaces/IScriptApi.cs b/OpenSim/Region/ScriptEngine/Interfaces/IScriptApi.cs new file mode 100644 index 0000000..2df41d0 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Interfaces/IScriptApi.cs @@ -0,0 +1,43 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using libsecondlife; +using OpenSim.Region.Environment.Scenes; + + +namespace OpenSim.Region.ScriptEngine.Interfaces +{ + public interface IScriptApi + { + // + // Each API has an identifier, which is used to load the + // proper runtime assembly at load time. + // + void Initialize(IScriptEngine engine, SceneObjectPart part, uint localID, LLUUID item); + } +} diff --git a/OpenSim/Region/ScriptEngine/Interfaces/IScriptEngine.cs b/OpenSim/Region/ScriptEngine/Interfaces/IScriptEngine.cs new file mode 100644 index 0000000..2fa67a4 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Interfaces/IScriptEngine.cs @@ -0,0 +1,59 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using log4net; +using System; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.Environment.Scenes; +using libsecondlife; +using Nini.Config; +using OpenSim.Region.ScriptEngine.Interfaces; + +namespace OpenSim.Region.ScriptEngine.Interfaces +{ + public interface IScriptEngine + { + // + // An interface for a script API module to communicate with + // the engine it's running under + // + + Scene World { get; } + IConfig Config { get; } + Object AsyncCommands { get; } + ILog Log { get; } + + bool PostScriptEvent(LLUUID itemID, EventParams parms); + bool PostObjectEvent(uint localID, EventParams parms); + void ResetScript(LLUUID itemID); + void SetScriptState(LLUUID itemID, bool state); + bool GetScriptState(LLUUID itemID); + void SetState(LLUUID itemID, string newState); + + DetectParams GetDetectParams(LLUUID item, int number); + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/ApiManager.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/ApiManager.cs new file mode 100644 index 0000000..f7f2676 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/ApiManager.cs @@ -0,0 +1,79 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Reflection; +using OpenSim.Region.ScriptEngine.Interfaces; + +namespace OpenSim.Region.ScriptEngine.Shared.Api +{ + public class ApiManager + { + private Dictionary m_Apis = new Dictionary(); + + public string[] GetApis() + { + if(m_Apis.Count > 0) + { + List l = new List(m_Apis.Keys); + return l.ToArray(); + } + + Assembly a = Assembly.GetExecutingAssembly(); + + Type[] types = a.GetExportedTypes(); + + foreach (Type t in types) + { + string name = t.ToString(); + int idx = name.LastIndexOf('.'); + if(idx != -1) + name = name.Substring(idx+1); + + if(name.EndsWith("_Api")) + { + name = name.Substring(0, name.Length - 4); + m_Apis[name] = t; + } + } + + List ret = new List(m_Apis.Keys); + return ret.ToArray(); + } + + public IScriptApi CreateApi(string api) + { + if(!m_Apis.ContainsKey(api)) + return null; + + IScriptApi ret = (IScriptApi)(Activator.CreateInstance(m_Apis[api])); + return ret; + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/AsyncCommandManager.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/AsyncCommandManager.cs new file mode 100644 index 0000000..8c967a2 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/AsyncCommandManager.cs @@ -0,0 +1,308 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Threading; +using libsecondlife; +using OpenSim.Framework; +using OpenSim.Region.Environment.Interfaces; +using OpenSim.Region.ScriptEngine.Interfaces; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.ScriptEngine.Shared.Api.Plugins; +using Timer=OpenSim.Region.ScriptEngine.Shared.Api.Plugins.Timer; + +namespace OpenSim.Region.ScriptEngine.Shared.Api +{ + /// + /// Handles LSL commands that takes long time and returns an event, for example timers, HTTP requests, etc. + /// + public class AsyncCommandManager + { + private static Thread cmdHandlerThread; + private static int cmdHandlerThreadCycleSleepms; + + private static List m_Managers = new List(); + public IScriptEngine m_ScriptEngine; + + private Dataserver m_Dataserver; + private Timer m_Timer; + private HttpRequest m_HttpRequest; + private Listener m_Listener; + private SensorRepeat m_SensorRepeat; + private XmlRequest m_XmlRequest; + + public Dataserver DataserverPlugin + { + get { return m_Dataserver; } + } + + public Timer TimerPlugin + { + get { return m_Timer; } + } + + public HttpRequest HttpRequestPlugin + { + get { return m_HttpRequest; } + } + + public Listener ListenerPlugin + { + get { return m_Listener; } + } + + public SensorRepeat SensorRepeatPlugin + { + get { return m_SensorRepeat; } + } + + public XmlRequest XmlRequestPlugin + { + get { return m_XmlRequest; } + } + + public AsyncCommandManager[] Managers + { + get { return m_Managers.ToArray(); } + } + + public AsyncCommandManager(IScriptEngine _ScriptEngine) + { + m_ScriptEngine = _ScriptEngine; + if(!m_Managers.Contains(this)) + m_Managers.Add(this); + + ReadConfig(); + + // Create instances of all plugins + m_Dataserver = new Dataserver(this); + m_Timer = new Timer(this); + m_HttpRequest = new HttpRequest(this); + m_Listener = new Listener(this); + m_SensorRepeat = new SensorRepeat(this); + m_XmlRequest = new XmlRequest(this); + + StartThread(); + } + + private static void StartThread() + { + if (cmdHandlerThread == null) + { + // Start the thread that will be doing the work + cmdHandlerThread = new Thread(CmdHandlerThreadLoop); + cmdHandlerThread.Name = "AsyncLSLCmdHandlerThread"; + cmdHandlerThread.Priority = ThreadPriority.BelowNormal; + cmdHandlerThread.IsBackground = true; + cmdHandlerThread.Start(); + ThreadTracker.Add(cmdHandlerThread); + } + } + + public void ReadConfig() + { + cmdHandlerThreadCycleSleepms = m_ScriptEngine.Config.GetInt("AsyncLLCommandLoopms", 100); + } + + ~AsyncCommandManager() + { + // Shut down thread + try + { + if (cmdHandlerThread != null) + { + if (cmdHandlerThread.IsAlive == true) + { + cmdHandlerThread.Abort(); + //cmdHandlerThread.Join(); + } + } + } + catch + { + } + } + + private static void CmdHandlerThreadLoop() + { + while (true) + { + try + { + while (true) + { + Thread.Sleep(cmdHandlerThreadCycleSleepms); + + foreach (AsyncCommandManager m in m_Managers) + { + m.DoOneCmdHandlerPass(); + } + } + } + catch + { + } + } + } + + public void DoOneCmdHandlerPass() + { + // Check timers + m_Timer.CheckTimerEvents(); + // Check HttpRequests + m_HttpRequest.CheckHttpRequests(); + // Check XMLRPCRequests + m_XmlRequest.CheckXMLRPCRequests(); + // Check Listeners + m_Listener.CheckListeners(); + // Check Sensors + m_SensorRepeat.CheckSenseRepeaterEvents(); + // Check dataserver + m_Dataserver.ExpireRequests(); + } + + /// + /// Remove a specific script (and all its pending commands) + /// + /// + /// + public void RemoveScript(uint localID, LLUUID itemID) + { + // Remove a specific script + + // Remove dataserver events + m_Dataserver.RemoveEvents(localID, itemID); + + // Remove from: Timers + m_Timer.UnSetTimerEvents(localID, itemID); + + // Remove from: HttpRequest + IHttpRequests iHttpReq = + m_ScriptEngine.World.RequestModuleInterface(); + iHttpReq.StopHttpRequest(localID, itemID); + + IWorldComm comms = m_ScriptEngine.World.RequestModuleInterface(); + comms.DeleteListener(itemID); + + IXMLRPC xmlrpc = m_ScriptEngine.World.RequestModuleInterface(); + xmlrpc.DeleteChannels(itemID); + xmlrpc.CancelSRDRequests(itemID); + + // Remove Sensors + m_SensorRepeat.UnSetSenseRepeaterEvents(localID, itemID); + + } + + public Object[] GetSerializationData(LLUUID itemID) + { + List data = new List(); + + Object[] listeners=m_Listener.GetSerializationData(itemID); + if (listeners.Length > 0) + { + data.Add("listener"); + data.Add(listeners.Length); + data.AddRange(listeners); + } + + Object[] timers=m_Timer.GetSerializationData(itemID); + if (timers.Length > 0) + { + data.Add("timer"); + data.Add(timers.Length); + data.AddRange(timers); + } + + Object[] sensors=m_SensorRepeat.GetSerializationData(itemID); + if (sensors.Length > 0) + { + data.Add("sensor"); + data.Add(sensors.Length); + data.AddRange(sensors); + } + + return data.ToArray(); + } + + public void CreateFromData(uint localID, LLUUID itemID, LLUUID hostID, + Object[] data) + { + int idx = 0; + int len; + + while (idx < data.Length) + { + string type = data[idx].ToString(); + len = (int)data[idx+1]; + idx+=2; + + if (len > 0) + { + Object[] item = new Object[len]; + Array.Copy(data, idx, item, 0, len); + + idx+=len; + + switch (type) + { + case "listener": + m_Listener.CreateFromData(localID, itemID, hostID, + item); + break; + case "timer": + m_Timer.CreateFromData(localID, itemID, hostID, item); + break; + case "sensor": + m_SensorRepeat.CreateFromData(localID, itemID, hostID, + item); + break; + } + } + } + } + + #region Check llRemoteData channels + + #endregion + + #region Check llListeners + + #endregion + + /// + /// If set to true then threads and stuff should try to make a graceful exit + /// + public bool PleaseShutdown + { + get { return _PleaseShutdown; } + set { _PleaseShutdown = value; } + } + private bool _PleaseShutdown = false; + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs new file mode 100644 index 0000000..7832633 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs @@ -0,0 +1,6583 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Runtime.Remoting.Lifetime; +using System.Text; +using System.Threading; +using Nini.Config; +using Axiom.Math; +using libsecondlife; +using OpenSim; +using OpenSim.Framework; +using OpenSim.Region.Environment; +using OpenSim.Region.Environment.Interfaces; +using OpenSim.Region.Environment.Modules.Avatar.Currency.SampleMoney; +using OpenSim.Region.Environment.Modules.World.Land; +using OpenSim.Region.Environment.Scenes; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.ScriptEngine.Shared.Api.Plugins; +using OpenSim.Region.ScriptEngine.Shared.ScriptBase; +using OpenSim.Region.ScriptEngine.Interfaces; +using OpenSim.Region.ScriptEngine.Shared.Api.Interfaces; + +namespace OpenSim.Region.ScriptEngine.Shared.Api +{ + /// + /// Contains all LSL ll-functions. This class will be in Default AppDomain. + /// + public class LSL_Api : MarshalByRefObject, ILSL_Api, IScriptApi + { + // private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); + + internal IScriptEngine m_ScriptEngine; + internal SceneObjectPart m_host; + internal uint m_localID; + internal LLUUID m_itemID; + internal bool throwErrorOnNotImplemented = true; + internal static AsyncCommandManager AsyncCommands = null; + + public void Initialize(IScriptEngine ScriptEngine, SceneObjectPart host, uint localID, LLUUID itemID) + { + m_ScriptEngine = ScriptEngine; + m_host = host; + m_localID = localID; + m_itemID = itemID; + + AsyncCommands = (AsyncCommandManager)ScriptEngine.AsyncCommands; + } + + private DateTime m_timer = DateTime.Now; + private bool m_waitingForScriptAnswer=false; + + + // Object never expires + public override Object InitializeLifetimeService() + { + ILease lease = (ILease)base.InitializeLifetimeService(); + + if (lease.CurrentState == LeaseState.Initial) + { + lease.InitialLeaseTime = TimeSpan.Zero; + } + return lease; + } + + public Scene World + { + get { return m_ScriptEngine.World; } + } + + public void state(string newState) + { + m_ScriptEngine.SetState(m_itemID, newState); + } + + public void llSay(int channelID, string text) + { + m_host.AddScriptLPS(1); + + if (text.Length > 1023) + text = text.Substring(0, 1023); + + World.SimChat(Helpers.StringToField(text), + ChatTypeEnum.Say, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false); + + IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); + wComm.DeliverMessage(ChatTypeEnum.Say, channelID, m_host.Name, m_host.UUID, text); + } + + // Extension commands use this: + public ICommander GetCommander(string name) + { + return World.GetCommander(name); + } + + private LLUUID InventorySelf() + { + LLUUID invItemID = new LLUUID(); + + foreach (KeyValuePair inv in m_host.TaskInventory) + { + if (inv.Value.Type == 10 && inv.Value.ItemID == m_itemID) + { + invItemID = inv.Key; + break; + } + } + + return invItemID; + } + + private LLUUID InventoryKey(string name, int type) + { + m_host.AddScriptLPS(1); + foreach (KeyValuePair inv in m_host.TaskInventory) + { + if (inv.Value.Name == name) + { + if (inv.Value.Type != type) + return LLUUID.Zero; + + return inv.Value.AssetID.ToString(); + } + } + return LLUUID.Zero; + } + + private LLUUID InventoryKey(string name) + { + m_host.AddScriptLPS(1); + foreach (KeyValuePair inv in m_host.TaskInventory) + { + if (inv.Value.Name == name) + { + return inv.Value.AssetID.ToString(); + } + } + return LLUUID.Zero; + } + + + /// + /// accepts a valid LLUUID, -or- a name of an inventory item. + /// Returns a valid LLUUID or LLUUID.Zero if key invalid and item not found + /// in prim inventory. + /// + /// + /// + private LLUUID KeyOrName(string k) + { + LLUUID key = LLUUID.Zero; + + // if we can parse the string as a key, use it. + if (LLUUID.TryParse(k, out key)) + { + return key; + } + // else try to locate the name in inventory of object. found returns key, + // not found returns LLUUID.Zero which will translate to the default particle texture + else + { + return InventoryKey(k); + } + } + + public void osSetRegionWaterHeight(double height) + { + m_host.AddScriptLPS(1); + //Check to make sure that the script's owner is the estate manager/master + //World.Permissions.GenericEstatePermission( + if (World.ExternalChecks.ExternalChecksCanBeGodLike(m_host.OwnerID)) + { + World.EventManager.TriggerRequestChangeWaterHeight((float)height); + } + } + + //These are the implementations of the various ll-functions used by the LSL scripts. + //starting out, we use the System.Math library for trig functions. - ckrinke 8-14-07 + public double llSin(double f) + { + m_host.AddScriptLPS(1); + return (double)Math.Sin(f); + } + + public double llCos(double f) + { + m_host.AddScriptLPS(1); + return (double)Math.Cos(f); + } + + public double llTan(double f) + { + m_host.AddScriptLPS(1); + return (double)Math.Tan(f); + } + + public double llAtan2(double x, double y) + { + m_host.AddScriptLPS(1); + return (double)Math.Atan2(y, x); + } + + public double llSqrt(double f) + { + m_host.AddScriptLPS(1); + return (double)Math.Sqrt(f); + } + + public double llPow(double fbase, double fexponent) + { + m_host.AddScriptLPS(1); + return (double)Math.Pow(fbase, fexponent); + } + + public LSL_Types.LSLInteger llAbs(int i) + { + m_host.AddScriptLPS(1); + return (int)Math.Abs(i); + } + + public double llFabs(double f) + { + m_host.AddScriptLPS(1); + return (double)Math.Abs(f); + } + + public double llFrand(double mag) + { + m_host.AddScriptLPS(1); + lock (Util.RandomClass) + { + return Util.RandomClass.NextDouble() * mag; + } + } + + public LSL_Types.LSLInteger llFloor(double f) + { + m_host.AddScriptLPS(1); + return (int)Math.Floor(f); + } + + public LSL_Types.LSLInteger llCeil(double f) + { + m_host.AddScriptLPS(1); + return (int)Math.Ceiling(f); + } + + // Xantor 01/May/2008 fixed midpointrounding (2.5 becomes 3.0 instead of 2.0, default = ToEven) + public LSL_Types.LSLInteger llRound(double f) + { + m_host.AddScriptLPS(1); + return (int)Math.Round(f, MidpointRounding.AwayFromZero); + } + + //This next group are vector operations involving squaring and square root. ckrinke + public double llVecMag(LSL_Types.Vector3 v) + { + m_host.AddScriptLPS(1); + return LSL_Types.Vector3.Mag(v); + } + + public LSL_Types.Vector3 llVecNorm(LSL_Types.Vector3 v) + { + m_host.AddScriptLPS(1); + double mag = LSL_Types.Vector3.Mag(v); + LSL_Types.Vector3 nor = new LSL_Types.Vector3(); + nor.x = v.x / mag; + nor.y = v.y / mag; + nor.z = v.z / mag; + return nor; + } + + public double llVecDist(LSL_Types.Vector3 a, LSL_Types.Vector3 b) + { + m_host.AddScriptLPS(1); + double dx = a.x - b.x; + double dy = a.y - b.y; + double dz = a.z - b.z; + return Math.Sqrt(dx * dx + dy * dy + dz * dz); + } + + //Now we start getting into quaternions which means sin/cos, matrices and vectors. ckrinke + + // Utility function for llRot2Euler + + // normalize an angle between 0 - 2*PI (0 and 360 degrees) + private double NormalizeAngle(double angle) + { + angle = angle % (Math.PI * 2); + if (angle < 0) angle = angle + Math.PI * 2; + return angle; + } + + // Old implementation of llRot2Euler, now normalized + + public LSL_Types.Vector3 llRot2Euler(LSL_Types.Quaternion r) + { + m_host.AddScriptLPS(1); + //This implementation is from http://lslwiki.net/lslwiki/wakka.php?wakka=LibraryRotationFunctions. ckrinke + LSL_Types.Quaternion t = new LSL_Types.Quaternion(r.x * r.x, r.y * r.y, r.z * r.z, r.s * r.s); + double m = (t.x + t.y + t.z + t.s); + if (m == 0) return new LSL_Types.Vector3(); + double n = 2 * (r.y * r.s + r.x * r.z); + double p = m * m - n * n; + if (p > 0) + return new LSL_Types.Vector3(NormalizeAngle(Math.Atan2(2.0 * (r.x * r.s - r.y * r.z), (-t.x - t.y + t.z + t.s))), + NormalizeAngle(Math.Atan2(n, Math.Sqrt(p))), + NormalizeAngle(Math.Atan2(2.0 * (r.z * r.s - r.x * r.y), (t.x - t.y - t.z + t.s)))); + else if (n > 0) + return new LSL_Types.Vector3(0.0, Math.PI / 2, NormalizeAngle(Math.Atan2((r.z * r.s + r.x * r.y), 0.5 - t.x - t.z))); + else + return new LSL_Types.Vector3(0.0, -Math.PI / 2, NormalizeAngle(Math.Atan2((r.z * r.s + r.x * r.y), 0.5 - t.x - t.z))); + } + + // Xantor's newer llEuler2Rot() *try the second* inverted quaternions (-x,-y,-z,w) as LL seems to like + // New and improved, now actually works as described. Prim rotates as expected as does llRot2Euler. + + /* From wiki: + The Euler angle vector (in radians) is converted to a rotation by doing the rotations around the 3 axes + in Z, Y, X order. So llEuler2Rot(<1.0, 2.0, 3.0> * DEG_TO_RAD) generates a rotation by taking the zero rotation, + a vector pointing along the X axis, first rotating it 3 degrees around the global Z axis, then rotating the resulting + vector 2 degrees around the global Y axis, and finally rotating that 1 degree around the global X axis. + */ + + public LSL_Types.Quaternion llEuler2Rot(LSL_Types.Vector3 v) + { + m_host.AddScriptLPS(1); + + double x,y,z,s,s_i; + + double cosX = Math.Cos(v.x); + double cosY = Math.Cos(v.y); + double cosZ = Math.Cos(v.z); + double sinX = Math.Sin(v.x); + double sinY = Math.Sin(v.y); + double sinZ = Math.Sin(v.z); + + s = Math.Sqrt(cosY * cosZ - sinX * sinY * sinZ + cosX * cosZ + cosX * cosY + 1.0f) * 0.5f; + if (Math.Abs(s) < 0.00001) // null rotation + { + x = 0.0f; + y = 1.0f; + z = 0.0f; + } + else + { + s_i = 1.0f / (4.0f * s); + x = - (-sinX * cosY - cosX * sinY * sinZ - sinX * cosZ) * s_i; + y = - (-cosX * sinY * cosZ + sinX * sinZ - sinY) * s_i; + z = - (-cosY * sinZ - sinX * sinY * cosZ - cosX * sinZ) * s_i; + } + return new LSL_Types.Quaternion(x, y, z, s); + } + + public LSL_Types.Quaternion llAxes2Rot(LSL_Types.Vector3 fwd, LSL_Types.Vector3 left, LSL_Types.Vector3 up) + { + m_host.AddScriptLPS(1); + NotImplemented("llAxes2Rot"); + return new LSL_Types.Quaternion(); + } + + public LSL_Types.Vector3 llRot2Fwd(LSL_Types.Quaternion r) + { + m_host.AddScriptLPS(1); + return (new LSL_Types.Vector3(1,0,0) * r); + } + + public LSL_Types.Vector3 llRot2Left(LSL_Types.Quaternion r) + { + m_host.AddScriptLPS(1); + return (new LSL_Types.Vector3(0, 1, 0) * r); + } + + public LSL_Types.Vector3 llRot2Up(LSL_Types.Quaternion r) + { + m_host.AddScriptLPS(1); + return (new LSL_Types.Vector3(0, 0, 1) * r); + } + + public LSL_Types.Quaternion llRotBetween(LSL_Types.Vector3 a, LSL_Types.Vector3 b) + { + //A and B should both be normalized + m_host.AddScriptLPS(1); + double dotProduct = LSL_Types.Vector3.Dot(a, b); + LSL_Types.Vector3 crossProduct = LSL_Types.Vector3.Cross(a, b); + double magProduct = LSL_Types.Vector3.Mag(a) * LSL_Types.Vector3.Mag(b); + double angle = Math.Acos(dotProduct / magProduct); + LSL_Types.Vector3 axis = LSL_Types.Vector3.Norm(crossProduct); + double s = Math.Sin(angle / 2); + + return new LSL_Types.Quaternion(axis.x * s, axis.y * s, axis.z * s, (float)Math.Cos(angle / 2)); + } + + public void llWhisper(int channelID, string text) + { + m_host.AddScriptLPS(1); + + if (text.Length > 1023) + text = text.Substring(0, 1023); + + World.SimChat(Helpers.StringToField(text), + ChatTypeEnum.Whisper, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false); + + IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); + wComm.DeliverMessage(ChatTypeEnum.Whisper, channelID, m_host.Name, m_host.UUID, text); + } + + public void llShout(int channelID, string text) + { + m_host.AddScriptLPS(1); + + if (text.Length > 1023) + text = text.Substring(0, 1023); + + World.SimChat(Helpers.StringToField(text), + ChatTypeEnum.Shout, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID, true); + + IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); + wComm.DeliverMessage(ChatTypeEnum.Shout, channelID, m_host.Name, m_host.UUID, text); + } + + public void llRegionSay(int channelID, string text) + { + if (channelID == 0) + { + LSLError("Cannot use llRegionSay() on channel 0"); + return; + } + + if (text.Length > 1023) + text = text.Substring(0, 1023); + + m_host.AddScriptLPS(1); + + IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); + wComm.DeliverMessage(ChatTypeEnum.Region, channelID, m_host.Name, m_host.UUID, text); + } + + public LSL_Types.LSLInteger llListen(int channelID, string name, string ID, string msg) + { + m_host.AddScriptLPS(1); + LLUUID keyID; + LLUUID.TryParse(ID, out keyID); + IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); + return wComm.Listen(m_localID, m_itemID, m_host.UUID, channelID, name, keyID, msg); + } + + public void llListenControl(int number, int active) + { + m_host.AddScriptLPS(1); + IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); + wComm.ListenControl(m_itemID, number, active); + } + + public void llListenRemove(int number) + { + m_host.AddScriptLPS(1); + IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); + wComm.ListenRemove(m_itemID, number); + } + + public void llSensor(string name, string id, int type, double range, double arc) + { + m_host.AddScriptLPS(1); + LLUUID keyID = LLUUID.Zero; + LLUUID.TryParse(id, out keyID); + + AsyncCommands.SensorRepeatPlugin.SenseOnce(m_localID, m_itemID, name, keyID, type, range, arc, m_host); + } + + public void llSensorRepeat(string name, string id, int type, double range, double arc, double rate) + { + m_host.AddScriptLPS(1); + LLUUID keyID = LLUUID.Zero; + LLUUID.TryParse(id, out keyID); + + AsyncCommands.SensorRepeatPlugin.SetSenseRepeatEvent(m_localID, m_itemID, name, keyID, type, range, arc, rate, m_host); + } + + public void llSensorRemove() + { + m_host.AddScriptLPS(1); + AsyncCommands.SensorRepeatPlugin.UnSetSenseRepeaterEvents(m_localID, m_itemID); + } + + public string resolveName(LLUUID objecUUID) + { + // try avatar username surname + UserProfileData profile = World.CommsManager.UserService.GetUserProfile(objecUUID); + if (profile != null) + { + string avatarname = profile.FirstName + " " + profile.SurName; + return avatarname; + } + // try an scene object + SceneObjectPart SOP = World.GetSceneObjectPart(objecUUID); + if (SOP != null) + { + string objectname = SOP.Name; + return objectname; + } + + EntityBase SensedObject; + lock (World.Entities) + { + World.Entities.TryGetValue(objecUUID, out SensedObject); + } + + if (SensedObject == null) + return String.Empty; + return SensedObject.Name; + } + + public string llDetectedName(int number) + { + m_host.AddScriptLPS(1); + DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); + if (d == null) + return String.Empty; + return d.Name; + } + + public string llDetectedKey(int number) + { + m_host.AddScriptLPS(1); + DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); + if (d == null) + return String.Empty; + return d.Key.ToString(); + } + + public string llDetectedOwner(int number) + { + m_host.AddScriptLPS(1); + DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); + if (d == null) + return String.Empty; + return d.Owner.ToString(); + } + + public LSL_Types.LSLInteger llDetectedType(int number) + { + m_host.AddScriptLPS(1); + DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); + if (d == null) + return 0; + return new LSL_Types.LSLInteger(d.Type); + } + + public LSL_Types.Vector3 llDetectedPos(int number) + { + m_host.AddScriptLPS(1); + DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); + if (d == null) + return new LSL_Types.Vector3(); + return d.Position; + } + + public LSL_Types.Vector3 llDetectedVel(int number) + { + m_host.AddScriptLPS(1); + DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); + if (d == null) + return new LSL_Types.Vector3(); + return d.Velocity; + } + + public LSL_Types.Vector3 llDetectedGrab(int number) + { + m_host.AddScriptLPS(1); + DetectParams parms = m_ScriptEngine.GetDetectParams(m_itemID, number); + if (parms == null) + return new LSL_Types.Vector3(0, 0, 0); + + return parms.OffsetPos; + } + + public LSL_Types.Quaternion llDetectedRot(int number) + { + m_host.AddScriptLPS(1); + DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); + if (d == null) + return new LSL_Types.Quaternion(); + return d.Rotation; + } + + public LSL_Types.LSLInteger llDetectedGroup(int number) + { + m_host.AddScriptLPS(1); + DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); + if (d == null) + return new LSL_Types.LSLInteger(0); + if (m_host.GroupID == d.Group) + return new LSL_Types.LSLInteger(1); + return new LSL_Types.LSLInteger(0); + } + + public LSL_Types.LSLInteger llDetectedLinkNumber(int number) + { + m_host.AddScriptLPS(1); + DetectParams parms = m_ScriptEngine.GetDetectParams(m_itemID, number); + if (parms == null) + return new LSL_Types.LSLInteger(0); + + return new LSL_Types.LSLInteger(parms.LinkNum); + } + + public void llDie() + { + m_host.AddScriptLPS(1); + World.DeleteSceneObject(m_host.ParentGroup); + } + + public double llGround(LSL_Types.Vector3 offset) + { + m_host.AddScriptLPS(1); + int x = (int)(m_host.AbsolutePosition.X + offset.x); + int y = (int)(m_host.AbsolutePosition.Y + offset.y); + return World.GetLandHeight(x, y); + } + + public double llCloud(LSL_Types.Vector3 offset) + { + m_host.AddScriptLPS(1); + NotImplemented("llCloud"); + return 0; + } + + public LSL_Types.Vector3 llWind(LSL_Types.Vector3 offset) + { + m_host.AddScriptLPS(1); + NotImplemented("llWind"); + return new LSL_Types.Vector3(); + } + + public void llSetStatus(int status, int value) + { + m_host.AddScriptLPS(1); + + int statusrotationaxis = 0; + + if ((status & ScriptBaseClass.STATUS_PHYSICS) == ScriptBaseClass.STATUS_PHYSICS) + { + if (value == 1) + m_host.ScriptSetPhysicsStatus(true); + else + m_host.ScriptSetPhysicsStatus(false); + } + + if ((status & ScriptBaseClass.STATUS_PHANTOM) == ScriptBaseClass.STATUS_PHANTOM) + { + if (value == 1) + m_host.ScriptSetPhantomStatus(true); + else + m_host.ScriptSetPhantomStatus(false); + } + + if ((status & ScriptBaseClass.STATUS_CAST_SHADOWS) == ScriptBaseClass.STATUS_CAST_SHADOWS) + { + m_host.AddFlag(LLObject.ObjectFlags.CastShadows); + } + + if ((status & ScriptBaseClass.STATUS_ROTATE_X) == ScriptBaseClass.STATUS_ROTATE_X) + { + statusrotationaxis |= ScriptBaseClass.STATUS_ROTATE_X; + } + + if ((status & ScriptBaseClass.STATUS_ROTATE_Y) == ScriptBaseClass.STATUS_ROTATE_Y) + { + statusrotationaxis |= ScriptBaseClass.STATUS_ROTATE_Y; + } + + if ((status & ScriptBaseClass.STATUS_ROTATE_Z) == ScriptBaseClass.STATUS_ROTATE_Z) + { + statusrotationaxis |= ScriptBaseClass.STATUS_ROTATE_Z; + } + + if ((status & ScriptBaseClass.STATUS_BLOCK_GRAB) == ScriptBaseClass.STATUS_BLOCK_GRAB) + { + NotImplemented("llSetStatus - STATUS_BLOCK_GRAB"); + } + + if ((status & ScriptBaseClass.STATUS_DIE_AT_EDGE) == ScriptBaseClass.STATUS_DIE_AT_EDGE) + { + if (value == 1) + m_host.SetDieAtEdge(true); + else + m_host.SetDieAtEdge(false); + } + + if ((status & ScriptBaseClass.STATUS_RETURN_AT_EDGE) == ScriptBaseClass.STATUS_RETURN_AT_EDGE) + { + NotImplemented("llSetStatus - STATUS_RETURN_AT_EDGE"); + } + + if ((status & ScriptBaseClass.STATUS_SANDBOX) == ScriptBaseClass.STATUS_SANDBOX) + { + NotImplemented("llSetStatus - STATUS_SANDBOX"); + } + + if (statusrotationaxis != 0) + { + m_host.SetAxisRotation(statusrotationaxis, value); + } + } + + public LSL_Types.LSLInteger llGetStatus(int status) + { + m_host.AddScriptLPS(1); + // Console.WriteLine(m_host.UUID.ToString() + " status is " + m_host.GetEffectiveObjectFlags().ToString()); + switch (status) + { + case ScriptBaseClass.STATUS_PHYSICS: + if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Physics) == (uint)LLObject.ObjectFlags.Physics) + { + return 1; + } + return 0; + + case ScriptBaseClass.STATUS_PHANTOM: + if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Phantom) == (uint)LLObject.ObjectFlags.Phantom) + { + return 1; + } + return 0; + + case ScriptBaseClass.STATUS_CAST_SHADOWS: + if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.CastShadows) == (uint)LLObject.ObjectFlags.CastShadows) + { + return 1; + } + return 0; + + case ScriptBaseClass.STATUS_BLOCK_GRAB: + NotImplemented("llGetStatus - STATUS_BLOCK_GRAB"); + return 0; + + case ScriptBaseClass.STATUS_DIE_AT_EDGE: + if (m_host.GetDieAtEdge()) + return 1; + else + return 0; + + case ScriptBaseClass.STATUS_RETURN_AT_EDGE: + NotImplemented("llGetStatus - STATUS_RETURN_AT_EDGE"); + return 0; + + case ScriptBaseClass.STATUS_ROTATE_X: + NotImplemented("llGetStatus - STATUS_ROTATE_X"); + return 0; + + case ScriptBaseClass.STATUS_ROTATE_Y: + NotImplemented("llGetStatus - STATUS_ROTATE_Y"); + return 0; + + case ScriptBaseClass.STATUS_ROTATE_Z: + NotImplemented("llGetStatus - STATUS_ROTATE_Z"); + return 0; + + case ScriptBaseClass.STATUS_SANDBOX: + NotImplemented("llGetStatus - STATUS_SANDBOX"); + return 0; + } + return 0; + } + + public void llSetScale(LSL_Types.Vector3 scale) + { + m_host.AddScriptLPS(1); + SetScale(m_host, scale); + } + + private void SetScale(SceneObjectPart part, LSL_Types.Vector3 scale) + { + // TODO: this needs to trigger a persistance save as well + LLVector3 tmp = part.Scale; + tmp.X = (float)scale.x; + tmp.Y = (float)scale.y; + tmp.Z = (float)scale.z; + part.Scale = tmp; + part.SendFullUpdateToAllClients(); + } + + public LSL_Types.Vector3 llGetScale() + { + m_host.AddScriptLPS(1); + return new LSL_Types.Vector3(m_host.Scale.X, m_host.Scale.Y, m_host.Scale.Z); + } + + public void llSetColor(LSL_Types.Vector3 color, int face) + { + m_host.AddScriptLPS(1); + + SetColor(m_host, color, face); + } + + private void SetColor(SceneObjectPart part, LSL_Types.Vector3 color, int face) + { + LLObject.TextureEntry tex = part.Shape.Textures; + LLColor texcolor; + if (face > -1) + { + texcolor = tex.CreateFace((uint)face).RGBA; + texcolor.R = (float)Math.Abs(color.x - 1); + texcolor.G = (float)Math.Abs(color.y - 1); + texcolor.B = (float)Math.Abs(color.z - 1); + tex.FaceTextures[face].RGBA = texcolor; + part.UpdateTexture(tex); + return; + } + else if (face == -1) + { + for (uint i = 0; i < 32; i++) + { + if (tex.FaceTextures[i] != null) + { + texcolor = tex.FaceTextures[i].RGBA; + texcolor.R = (float)Math.Abs(color.x - 1); + texcolor.G = (float)Math.Abs(color.y - 1); + texcolor.B = (float)Math.Abs(color.z - 1); + tex.FaceTextures[i].RGBA = texcolor; + } + texcolor = tex.DefaultTexture.RGBA; + texcolor.R = (float)Math.Abs(color.x - 1); + texcolor.G = (float)Math.Abs(color.y - 1); + texcolor.B = (float)Math.Abs(color.z - 1); + tex.DefaultTexture.RGBA = texcolor; + } + part.UpdateTexture(tex); + return; + } + } + + public double llGetAlpha(int face) + { + m_host.AddScriptLPS(1); + LLObject.TextureEntry tex = m_host.Shape.Textures; + if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color + { + return (double)((tex.DefaultTexture.RGBA.A * 255) / 255); + } + if (face > -1) + { + return (double)((tex.GetFace((uint)face).RGBA.A * 255) / 255); + } + return 0; + } + + public void llSetAlpha(double alpha, int face) + { + m_host.AddScriptLPS(1); + + SetAlpha(m_host, alpha, face); + } + + private void SetAlpha(SceneObjectPart part, double alpha, int face) + { + LLObject.TextureEntry tex = part.Shape.Textures; + LLColor texcolor; + if (face > -1) + { + texcolor = tex.CreateFace((uint)face).RGBA; + texcolor.A = (float)Math.Abs(alpha - 1); + tex.FaceTextures[face].RGBA = texcolor; + part.UpdateTexture(tex); + return; + } + else if (face == -1) + { + for (int i = 0; i < 32; i++) + { + if (tex.FaceTextures[i] != null) + { + texcolor = tex.FaceTextures[i].RGBA; + texcolor.A = (float)Math.Abs(alpha - 1); + tex.FaceTextures[i].RGBA = texcolor; + } + } + texcolor = tex.DefaultTexture.RGBA; + texcolor.A = (float)Math.Abs(alpha - 1); + tex.DefaultTexture.RGBA = texcolor; + part.UpdateTexture(tex); + return; + } + } + + private void SetFlexi(SceneObjectPart part, bool flexi, int softness, float gravity, float friction, + float wind, float tension, LSL_Types.Vector3 Force) + { + if (part == null) + return; + + bool needs_fakedelete = false; + if (flexi) + { + if (!part.Shape.FlexiEntry) + { + needs_fakedelete = true; + } + part.Shape.FlexiEntry = true; // this setting flexi true isn't working, but the below parameters do + // work once the prim is already flexi + part.Shape.FlexiSoftness = softness; + part.Shape.FlexiGravity = gravity; + part.Shape.FlexiDrag = friction; + part.Shape.FlexiWind = wind; + part.Shape.FlexiTension = tension; + part.Shape.FlexiForceX = (float)Force.x; + part.Shape.FlexiForceY = (float)Force.y; + part.Shape.FlexiForceZ = (float)Force.z; + part.Shape.PathCurve = 0x80; + + } + else + { + if (part.Shape.FlexiEntry) + { + needs_fakedelete = true; + } + part.Shape.FlexiEntry = false; + } + + needs_fakedelete = false; + if (needs_fakedelete) + { + if (part.ParentGroup != null) + { + part.ParentGroup.FakeDeleteGroup(); + } + } + + part.ScheduleFullUpdate(); + } + + private void SetPointLight(SceneObjectPart part, bool light, LSL_Types.Vector3 color, float intensity, float radius, float falloff) + { + if (part == null) + return; + + if (light) + { + part.Shape.LightEntry = true; + part.Shape.LightColorR = (float)color.x; + part.Shape.LightColorG = (float)color.y; + part.Shape.LightColorB = (float)color.z; + part.Shape.LightIntensity = intensity; + part.Shape.LightRadius = radius; + part.Shape.LightFalloff = falloff; + } + else + { + part.Shape.LightEntry = false; + } + + part.ScheduleFullUpdate(); + } + + + + public LSL_Types.Vector3 llGetColor(int face) + { + m_host.AddScriptLPS(1); + LLObject.TextureEntry tex = m_host.Shape.Textures; + LLColor texcolor; + LSL_Types.Vector3 rgb; + if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color + { + texcolor = tex.DefaultTexture.RGBA; + rgb.x = (255 - (texcolor.R * 255)) / 255; + rgb.y = (255 - (texcolor.G * 255)) / 255; + rgb.z = (255 - (texcolor.B * 255)) / 255; + return rgb; + } + if (face > -1) + { + texcolor = tex.GetFace((uint)face).RGBA; + rgb.x = (255 - (texcolor.R * 255)) / 255; + rgb.y = (255 - (texcolor.G * 255)) / 255; + rgb.z = (255 - (texcolor.B * 255)) / 255; + return rgb; + } + else + { + return new LSL_Types.Vector3(); + } + } + + public void llSetTexture(string texture, int face) + { + m_host.AddScriptLPS(1); + SetTexture(m_host, texture, face); + } + + private void SetTexture(SceneObjectPart part, string texture, int face) + { + LLUUID textureID=new LLUUID(); + + if (!LLUUID.TryParse(texture, out textureID)) + { + textureID=InventoryKey(texture, (int)AssetType.Texture); + } + + if (textureID == LLUUID.Zero) + return; + + LLObject.TextureEntry tex = part.Shape.Textures; + + if (face > -1) + { + LLObject.TextureEntryFace texface = tex.CreateFace((uint)face); + texface.TextureID = textureID; + tex.FaceTextures[face] = texface; + part.UpdateTexture(tex); + return; + } + else if (face == -1) + { + for (uint i = 0; i < 32; i++) + { + if (tex.FaceTextures[i] != null) + { + tex.FaceTextures[i].TextureID = textureID; + } + } + tex.DefaultTexture.TextureID = textureID; + part.UpdateTexture(tex); + return; + } + } + + public void llScaleTexture(double u, double v, int face) + { + m_host.AddScriptLPS(1); + + ScaleTexture(m_host, u, v, face); + } + + private void ScaleTexture(SceneObjectPart part, double u, double v, int face) + { + LLObject.TextureEntry tex = part.Shape.Textures; + if (face > -1) + { + LLObject.TextureEntryFace texface = tex.CreateFace((uint)face); + texface.RepeatU = (float)u; + texface.RepeatV = (float)v; + tex.FaceTextures[face] = texface; + part.UpdateTexture(tex); + return; + } + if (face == -1) + { + for (int i = 0; i < 32; i++) + { + if (tex.FaceTextures[i] != null) + { + tex.FaceTextures[i].RepeatU = (float)u; + tex.FaceTextures[i].RepeatV = (float)v; + } + } + tex.DefaultTexture.RepeatU = (float)u; + tex.DefaultTexture.RepeatV = (float)v; + part.UpdateTexture(tex); + return; + } + } + + public void llOffsetTexture(double u, double v, int face) + { + m_host.AddScriptLPS(1); + OffsetTexture(m_host, u, v, face); + } + + private void OffsetTexture(SceneObjectPart part, double u, double v, int face) + { + LLObject.TextureEntry tex = part.Shape.Textures; + if (face > -1) + { + LLObject.TextureEntryFace texface = tex.CreateFace((uint)face); + texface.OffsetU = (float)u; + texface.OffsetV = (float)v; + tex.FaceTextures[face] = texface; + part.UpdateTexture(tex); + return; + } + if (face == -1) + { + for (int i = 0; i < 32; i++) + { + if (tex.FaceTextures[i] != null) + { + tex.FaceTextures[i].OffsetU = (float)u; + tex.FaceTextures[i].OffsetV = (float)v; + } + } + tex.DefaultTexture.OffsetU = (float)u; + tex.DefaultTexture.OffsetV = (float)v; + part.UpdateTexture(tex); + return; + } + } + + public void llRotateTexture(double rotation, int face) + { + m_host.AddScriptLPS(1); + RotateTexture(m_host, rotation, face); + } + + private void RotateTexture(SceneObjectPart part, double rotation, int face) + { + LLObject.TextureEntry tex = part.Shape.Textures; + if (face > -1) + { + LLObject.TextureEntryFace texface = tex.CreateFace((uint)face); + texface.Rotation = (float)rotation; + tex.FaceTextures[face] = texface; + part.UpdateTexture(tex); + return; + } + if (face == -1) + { + for (int i = 0; i < 32; i++) + { + if (tex.FaceTextures[i] != null) + { + tex.FaceTextures[i].Rotation = (float)rotation; + } + } + tex.DefaultTexture.Rotation = (float)rotation; + part.UpdateTexture(tex); + return; + } + } + + public string llGetTexture(int face) + { + m_host.AddScriptLPS(1); + LLObject.TextureEntry tex = m_host.Shape.Textures; + if (face == -1) + { + face = 0; + } + if (face > -1) + { + LLObject.TextureEntryFace texface; + texface = tex.GetFace((uint)face); + return texface.TextureID.ToString(); + } + else + { + return String.Empty; + } + } + + public void llSetPos(LSL_Types.Vector3 pos) + { + m_host.AddScriptLPS(1); + + SetPos(m_host, pos); + } + + private void SetPos(SceneObjectPart part, LSL_Types.Vector3 pos) + { + if (part.ParentID != 0) + { + part.UpdateOffSet(new LLVector3((float)pos.x, (float)pos.y, (float)pos.z)); + } + else + { + part.UpdateGroupPosition(new LLVector3((float)pos.x, (float)pos.y, (float)pos.z)); + } + } + + public LSL_Types.Vector3 llGetPos() + { + m_host.AddScriptLPS(1); + return new LSL_Types.Vector3(m_host.AbsolutePosition.X, + m_host.AbsolutePosition.Y, + m_host.AbsolutePosition.Z); + } + + public LSL_Types.Vector3 llGetLocalPos() + { + m_host.AddScriptLPS(1); + if (m_host.ParentID != 0) + { + return new LSL_Types.Vector3(m_host.OffsetPosition.X, + m_host.OffsetPosition.Y, + m_host.OffsetPosition.Z); + } + else + { + return new LSL_Types.Vector3(m_host.AbsolutePosition.X, + m_host.AbsolutePosition.Y, + m_host.AbsolutePosition.Z); + } + } + + public void llSetRot(LSL_Types.Quaternion rot) + { + m_host.AddScriptLPS(1); + + SetRot(m_host, rot); + } + + private void SetRot(SceneObjectPart part, LSL_Types.Quaternion rot) + { + part.UpdateRotation(new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s)); + // Update rotation does not move the object in the physics scene if it's a linkset. + part.ParentGroup.AbsolutePosition = part.ParentGroup.AbsolutePosition; + } + + public LSL_Types.Quaternion llGetRot() + { + m_host.AddScriptLPS(1); + LLQuaternion q = m_host.RotationOffset; + return new LSL_Types.Quaternion(q.X, q.Y, q.Z, q.W); + } + + public LSL_Types.Quaternion llGetLocalRot() + { + m_host.AddScriptLPS(1); + return new LSL_Types.Quaternion(m_host.RotationOffset.X, m_host.RotationOffset.Y, m_host.RotationOffset.Z, m_host.RotationOffset.W); + } + + public void llSetForce(LSL_Types.Vector3 force, int local) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetForce"); + } + + public LSL_Types.Vector3 llGetForce() + { + m_host.AddScriptLPS(1); + NotImplemented("llGetForce"); + return new LSL_Types.Vector3(); + } + + public LSL_Types.LSLInteger llTarget(LSL_Types.Vector3 position, double range) + { + m_host.AddScriptLPS(1); + return m_host.registerTargetWaypoint(new LLVector3((float)position.x, (float)position.y, (float)position.z), (float)range); + + } + + public void llTargetRemove(int number) + { + m_host.AddScriptLPS(1); + m_host.unregisterTargetWaypoint(number); + } + + public LSL_Types.LSLInteger llRotTarget(LSL_Types.Quaternion rot, double error) + { + m_host.AddScriptLPS(1); + NotImplemented("llRotTarget"); + return 0; + } + + public void llRotTargetRemove(int number) + { + m_host.AddScriptLPS(1); + NotImplemented("llRotTargetRemove"); + } + + public void llMoveToTarget(LSL_Types.Vector3 target, double tau) + { + m_host.AddScriptLPS(1); + m_host.MoveToTarget(new LLVector3((float)target.x, (float)target.y, (float)target.z), (float)tau); + } + + public void llStopMoveToTarget() + { + m_host.AddScriptLPS(1); + m_host.StopMoveToTarget(); + } + + public void llApplyImpulse(LSL_Types.Vector3 force, int local) + { + m_host.AddScriptLPS(1); + //No energy force yet + + if (force.x > 20000) + force.x = 20000; + if (force.y > 20000) + force.y = 20000; + if (force.z > 20000) + force.z = 20000; + + if (local == 1) + { + m_host.ApplyImpulse(new LLVector3((float)force.x, (float)force.y, (float)force.z), true); + } + else + { + + m_host.ApplyImpulse(new LLVector3((float)force.x,(float)force.y,(float)force.z), false); + } + } + + public void llApplyRotationalImpulse(LSL_Types.Vector3 force, int local) + { + m_host.AddScriptLPS(1); + NotImplemented("llApplyRotationalImpulse"); + } + + public void llSetTorque(LSL_Types.Vector3 torque, int local) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetTorque"); + } + + public LSL_Types.Vector3 llGetTorque() + { + m_host.AddScriptLPS(1); + NotImplemented("llGetTorque"); + return new LSL_Types.Vector3(); + } + + public void llSetForceAndTorque(LSL_Types.Vector3 force, LSL_Types.Vector3 torque, int local) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetForceAndTorque"); + } + + public LSL_Types.Vector3 llGetVel() + { + m_host.AddScriptLPS(1); + return new LSL_Types.Vector3(m_host.Velocity.X, m_host.Velocity.Y, m_host.Velocity.Z); + } + + public LSL_Types.Vector3 llGetAccel() + { + m_host.AddScriptLPS(1); + return new LSL_Types.Vector3(m_host.Acceleration.X, m_host.Acceleration.Y, m_host.Acceleration.Z); + } + + public LSL_Types.Vector3 llGetOmega() + { + m_host.AddScriptLPS(1); + return new LSL_Types.Vector3(m_host.RotationalVelocity.X, m_host.RotationalVelocity.Y, m_host.RotationalVelocity.Z); + } + + public double llGetTimeOfDay() + { + m_host.AddScriptLPS(1); + NotImplemented("llGetTimeOfDay"); + return 0; + } + + public double llGetWallclock() + { + m_host.AddScriptLPS(1); + return DateTime.Now.TimeOfDay.TotalSeconds; + } + + public double llGetTime() + { + m_host.AddScriptLPS(1); + TimeSpan ScriptTime = DateTime.Now - m_timer; + return (double)((ScriptTime.TotalMilliseconds / 1000)*World.TimeDilation); + } + + public void llResetTime() + { + m_host.AddScriptLPS(1); + m_timer = DateTime.Now; + } + + public double llGetAndResetTime() + { + m_host.AddScriptLPS(1); + TimeSpan ScriptTime = DateTime.Now - m_timer; + m_timer = DateTime.Now; + return (double)((ScriptTime.TotalMilliseconds / 1000)*World.TimeDilation); + } + + public void llSound() + { + m_host.AddScriptLPS(1); + // This function has been deprecated + // see http://www.lslwiki.net/lslwiki/wakka.php?wakka=llSound + Deprecated("llSound"); + } + + // Xantor 20080528 PlaySound updated so it accepts an objectinventory name -or- a key to a sound + // 20080530 Updated to remove code duplication + public void llPlaySound(string sound, double volume) + { + m_host.AddScriptLPS(1); + + // send the sound, once, to all clients in range + m_host.SendSound(KeyOrName(sound).ToString(), volume, false, 0); + } + + // Xantor 20080528 we should do this differently. + // 1) apply the sound to the object + // 2) schedule full update + // just sending the sound out once doesn't work so well when other avatars come in view later on + // or when the prim gets moved, changed, sat on, whatever + // see large number of mantises (mantes?) + // 20080530 Updated to remove code duplication + // 20080530 Stop sound if there is one, otherwise volume only changes don't work + public void llLoopSound(string sound, double volume) + { + m_host.AddScriptLPS(1); + + if (m_host.Sound != LLUUID.Zero) + llStopSound(); + + m_host.Sound = KeyOrName(sound); + m_host.SoundGain = volume; + m_host.SoundFlags = 1; // looping + m_host.SoundRadius = 20; // Magic number, 20 seems reasonable. Make configurable? + + m_host.ScheduleFullUpdate(); + m_host.SendFullUpdateToAllClients(); + } + + public void llLoopSoundMaster(string sound, double volume) + { + m_host.AddScriptLPS(1); + NotImplemented("llLoopSoundMaster"); + } + + public void llLoopSoundSlave(string sound, double volume) + { + m_host.AddScriptLPS(1); + NotImplemented("llLoopSoundSlave"); + } + + public void llPlaySoundSlave(string sound, double volume) + { + m_host.AddScriptLPS(1); + NotImplemented("llPlaySoundSlave"); + } + + public void llTriggerSound(string sound, double volume) + { + m_host.AddScriptLPS(1); + m_host.SendSound(sound, volume, true, 0); + } + + // Xantor 20080528: Clear prim data of sound instead + public void llStopSound() + { + m_host.AddScriptLPS(1); + + m_host.Sound = LLUUID.Zero; + m_host.SoundGain = 0; + m_host.SoundFlags = 0; + m_host.SoundRadius = 0; + + m_host.ScheduleFullUpdate(); + m_host.SendFullUpdateToAllClients(); + + // m_host.SendSound(LLUUID.Zero.ToString(), 1.0, false, 2); + } + + public void llPreloadSound(string sound) + { + m_host.AddScriptLPS(1); + m_host.PreloadSound(sound); + } + + /// + /// Return a portion of the designated string bounded by + /// inclusive indices (start and end). As usual, the negative + /// indices, and the tolerance for out-of-bound values, makes + /// this more complicated than it might otherwise seem. + /// + + public string llGetSubString(string src, int start, int end) + { + + m_host.AddScriptLPS(1); + + // Normalize indices (if negative). + // After normlaization they may still be + // negative, but that is now relative to + // the start, rather than the end, of the + // sequence. + + if (start < 0) + { + start = src.Length+start; + } + if (end < 0) + { + end = src.Length+end; + } + + // Conventional substring + if (start <= end) + { + // Implies both bounds are out-of-range. + if (end < 0 || start >= src.Length) + { + return String.Empty; + } + // If end is positive, then it directly + // corresponds to the lengt of the substring + // needed (plus one of course). BUT, it + // must be within bounds. + if (end >= src.Length) + { + end = src.Length-1; + } + + if (start < 0) + { + return src.Substring(0,end+1); + } + // Both indices are positive + return src.Substring(start, (end+1) - start); + } + + // Inverted substring (end < start) + else + { + // Implies both indices are below the + // lower bound. In the inverted case, that + // means the entire string will be returned + // unchanged. + if (start < 0) + { + return src; + } + // If both indices are greater than the upper + // bound the result may seem initially counter + // intuitive. + if (end >= src.Length) + { + return src; + } + + if (end < 0) + { + if (start < src.Length) + { + return src.Substring(start); + } + else + { + return String.Empty; + } + } + else + { + if (start < src.Length) + { + return src.Substring(0,end+1) + src.Substring(start); + } + else + { + return src.Substring(0,end+1); + } + } + } + } + + /// + /// Delete substring removes the specified substring bounded + /// by the inclusive indices start and end. Indices may be + /// negative (indicating end-relative) and may be inverted, + /// i.e. end < start. + /// + + public string llDeleteSubString(string src, int start, int end) + { + + m_host.AddScriptLPS(1); + + // Normalize indices (if negative). + // After normlaization they may still be + // negative, but that is now relative to + // the start, rather than the end, of the + // sequence. + if (start < 0) + { + start = src.Length+start; + } + if (end < 0) + { + end = src.Length+end; + } + // Conventionally delimited substring + if (start <= end) + { + // If both bounds are outside of the existing + // string, then return unchanges. + if (end < 0 || start >= src.Length) + { + return src; + } + // At least one bound is in-range, so we + // need to clip the out-of-bound argument. + if (start < 0) + { + start = 0; + } + + if (end >= src.Length) + { + end = src.Length-1; + } + + return src.Remove(start,end-start+1); + } + // Inverted substring + else + { + // In this case, out of bounds means that + // the existing string is part of the cut. + if (start < 0 || end >= src.Length) + { + return String.Empty; + } + + if (end > 0) + { + if (start < src.Length) + { + return src.Remove(start).Remove(0,end+1); + } + else + { + return src.Remove(0,end+1); + } + } + else + { + if (start < src.Length) + { + return src.Remove(start); + } + else + { + return src; + } + } + } + } + + /// + /// Insert string inserts the specified string identified by src + /// at the index indicated by index. Index may be negative, in + /// which case it is end-relative. The index may exceed either + /// string bound, with the result being a concatenation. + /// + + public string llInsertString(string dest, int index, string src) + { + + m_host.AddScriptLPS(1); + + // Normalize indices (if negative). + // After normlaization they may still be + // negative, but that is now relative to + // the start, rather than the end, of the + // sequence. + if (index < 0) + { + index = dest.Length+index; + + // Negative now means it is less than the lower + // bound of the string. + + if (index < 0) + { + return src+dest; + } + + } + + if (index >= dest.Length) + { + return dest+src; + } + + // The index is in bounds. + // In this case the index refers to the index that will + // be assigned to the first character of the inserted string. + // So unlike the other string operations, we do not add one + // to get the correct string length. + return dest.Substring(0,index)+src+dest.Substring(index); + + } + + public string llToUpper(string src) + { + m_host.AddScriptLPS(1); + return src.ToUpper(); + } + + public string llToLower(string src) + { + m_host.AddScriptLPS(1); + return src.ToLower(); + } + + public LSL_Types.LSLInteger llGiveMoney(string destination, int amount) + { + LLUUID invItemID=InventorySelf(); + if (invItemID == LLUUID.Zero) + return 0; + + m_host.AddScriptLPS(1); + + if (m_host.TaskInventory[invItemID].PermsGranter == LLUUID.Zero) + return 0; + + if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_DEBIT) == 0) + { + LSLError("No permissions to give money"); + return 0; + } + + LLUUID toID=new LLUUID(); + + if (!LLUUID.TryParse(destination, out toID)) + { + LSLError("Bad key in llGiveMoney"); + return 0; + } + + IMoneyModule money=World.RequestModuleInterface(); + + if (money == null) + { + NotImplemented("llGiveMoney"); + return 0; + } + + bool result=money.ObjectGiveMoney(m_host.ParentGroup.RootPart.UUID, m_host.ParentGroup.RootPart.OwnerID, toID, amount); + + if (result) + return 1; + + return 0; + } + + public void llMakeExplosion() + { + m_host.AddScriptLPS(1); + NotImplemented("llMakeExplosion"); + } + + public void llMakeFountain() + { + m_host.AddScriptLPS(1); + NotImplemented("llMakeFountain"); + } + + public void llMakeSmoke() + { + m_host.AddScriptLPS(1); + NotImplemented("llMakeSmoke"); + } + + public void llMakeFire() + { + m_host.AddScriptLPS(1); + NotImplemented("llMakeFire"); + } + + public void llRezObject(string inventory, LSL_Types.Vector3 pos, LSL_Types.Vector3 vel, LSL_Types.Quaternion rot, int param) + { + m_host.AddScriptLPS(1); + //NotImplemented("llRezObject"); + bool found = false; + + // Instead of using return;, I'm using continue; because in our TaskInventory implementation + // it's possible to have two items with the same task inventory name. + // this is an easter egg of sorts. + + foreach (KeyValuePair inv in m_host.TaskInventory) + { + if (inv.Value.Name == inventory) + { + // make sure we're an object. + if (inv.Value.InvType != (int)InventoryType.Object) + { + llSay(0, "Unable to create requested object. Object is missing from database."); + continue; + } + + LLVector3 llpos = new LLVector3((float)pos.x, (float)pos.y, (float)pos.z); + + // test if we're further away then 10m + if (Util.GetDistanceTo(llpos, m_host.AbsolutePosition) > 10) + return; // wiki says, if it's further away then 10m, silently fail. + + LLVector3 llvel = new LLVector3((float)vel.x, (float)vel.y, (float)vel.z); + + // need the magnitude later + float velmag = (float)Util.GetMagnitude(llvel); + + SceneObjectGroup new_group = World.RezObject(inv.Value, llpos, new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s), llvel, param); + + // If either of these are null, then there was an unknown error. + if (new_group == null) + continue; + if (new_group.RootPart == null) + continue; + + // objects rezzed with this method are die_at_edge by default. + new_group.RootPart.SetDieAtEdge(true); + + m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams( + "object_rez", new Object[] { + new LSL_Types.LSLString( + new_group.RootPart.UUID.ToString()) }, + new DetectParams[0])); + + float groupmass = new_group.GetMass(); + + //Recoil. + llApplyImpulse(new LSL_Types.Vector3(llvel.X * groupmass, llvel.Y * groupmass, llvel.Z * groupmass), 0); + found = true; + //script delay + System.Threading.Thread.Sleep((int)((groupmass * velmag) / 10)); + break; + } + } + if (!found) + llSay(0, "Could not find object " + inventory); + } + + public void llLookAt(LSL_Types.Vector3 target, double strength, double damping) + { + m_host.AddScriptLPS(1); + NotImplemented("llLookAt"); + } + + public void llStopLookAt() + { + m_host.AddScriptLPS(1); + NotImplemented("llStopLookAt"); + } + + public void llSetTimerEvent(double sec) + { + m_host.AddScriptLPS(1); + // Setting timer repeat + AsyncCommands.TimerPlugin.SetTimerEvent(m_localID, m_itemID, sec); + } + + public void llSleep(double sec) + { + m_host.AddScriptLPS(1); + Thread.Sleep((int)(sec * 1000)); + } + + public double llGetMass() + { + m_host.AddScriptLPS(1); + return m_host.GetMass(); + } + + public void llCollisionFilter(string name, string id, int accept) + { + m_host.AddScriptLPS(1); + NotImplemented("llCollisionFilter"); + } + + public void llTakeControls(int controls, int accept, int pass_on) + { + if (!m_host.TaskInventory.ContainsKey(InventorySelf())) + { + return; + } + + if (m_host.TaskInventory[InventorySelf()].PermsGranter != LLUUID.Zero) + { + ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[InventorySelf()].PermsGranter); + + if (presence != null) + { + if ((m_host.TaskInventory[InventorySelf()].PermsMask & ScriptBaseClass.PERMISSION_TAKE_CONTROLS) != 0) + { + presence.RegisterControlEventsToScript(controls, accept, pass_on, m_localID, m_itemID); + + } + } + } + + m_host.AddScriptLPS(1); + //NotImplemented("llTakeControls"); + } + + public void llReleaseControls() + { + m_host.AddScriptLPS(1); + + if (!m_host.TaskInventory.ContainsKey(InventorySelf())) + { + return; + } + + if (m_host.TaskInventory[InventorySelf()].PermsGranter != LLUUID.Zero) + { + ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[InventorySelf()].PermsGranter); + + if (presence != null) + { + if ((m_host.TaskInventory[InventorySelf()].PermsMask & ScriptBaseClass.PERMISSION_TAKE_CONTROLS) != 0) + { + // Unregister controls from Presence + presence.UnRegisterControlEventsToScript(m_localID, m_itemID); + // Remove Take Control permission. + m_host.TaskInventory[InventorySelf()].PermsMask &= ~ScriptBaseClass.PERMISSION_TAKE_CONTROLS; + } + } + } + } + + public void llAttachToAvatar(int attachment) + { + m_host.AddScriptLPS(1); + NotImplemented("llAttachToAvatar"); + } + + public void llDetachFromAvatar() + { + m_host.AddScriptLPS(1); + NotImplemented("llDetachFromAvatar"); + } + + public void llTakeCamera() + { + m_host.AddScriptLPS(1); + NotImplemented("llTakeCamera"); + } + + public void llReleaseCamera() + { + m_host.AddScriptLPS(1); + NotImplemented("llReleaseCamera"); + } + + public string llGetOwner() + { + m_host.AddScriptLPS(1); + + return m_host.ObjectOwner.ToString(); + } + + public void llInstantMessage(string user, string message) + { + m_host.AddScriptLPS(1); + + // We may be able to use ClientView.SendInstantMessage here, but we need a client instance. + // InstantMessageModule.OnInstantMessage searches through a list of scenes for a client matching the toAgent, + // but I don't think we have a list of scenes available from here. + // (We also don't want to duplicate the code in OnInstantMessage if we can avoid it.) + + // user is a UUID + + // TODO: figure out values for client, fromSession, and imSessionID + // client.SendInstantMessage(m_host.UUID, fromSession, message, user, imSessionID, m_host.Name, AgentManager.InstantMessageDialog.MessageFromAgent, (uint)Util.UnixTimeSinceEpoch()); + LLUUID friendTransactionID = LLUUID.Random(); + + //m_pendingFriendRequests.Add(friendTransactionID, fromAgentID); + + GridInstantMessage msg = new GridInstantMessage(); + msg.fromAgentID = new Guid(m_host.UUID.ToString()); // fromAgentID.UUID; + msg.fromAgentSession = new Guid(friendTransactionID.ToString());// fromAgentSession.UUID; + msg.toAgentID = new Guid(user); // toAgentID.UUID; + msg.imSessionID = new Guid(friendTransactionID.ToString()); // This is the item we're mucking with here +// Console.WriteLine("[Scripting IM]: From:" + msg.fromAgentID.ToString() + " To: " + msg.toAgentID.ToString() + " Session:" + msg.imSessionID.ToString() + " Message:" + message); +// Console.WriteLine("[Scripting IM]: Filling Session: " + msg.imSessionID.ToString()); + msg.timestamp = (uint)Util.UnixTimeSinceEpoch();// timestamp; + //if (client != null) + //{ + msg.fromAgentName = m_host.Name;//client.FirstName + " " + client.LastName;// fromAgentName; + //} + //else + //{ + // msg.fromAgentName = "(hippos)";// Added for posterity. This means that we can't figure out who sent it + //} + msg.message = message; + msg.dialog = (byte)19; // messgage from script ??? // dialog; + msg.fromGroup = false;// fromGroup; + msg.offline = (byte)0; //offline; + msg.ParentEstateID = 0; //ParentEstateID; + msg.Position = new sLLVector3();// new sLLVector3(m_host.AbsolutePosition); + msg.RegionID = World.RegionInfo.RegionID.UUID;//RegionID.UUID; + msg.binaryBucket = new byte[0];// binaryBucket; + World.TriggerGridInstantMessage(msg, InstantMessageReceiver.IMModule); + // NotImplemented("llInstantMessage"); + } + + public void llEmail(string address, string subject, string message) + { + m_host.AddScriptLPS(1); + NotImplemented("llEmail"); + } + + public void llGetNextEmail(string address, string subject) + { + m_host.AddScriptLPS(1); + NotImplemented("llGetNextEmail"); + } + + public string llGetKey() + { + m_host.AddScriptLPS(1); + return m_host.UUID.ToString(); + } + + public void llSetBuoyancy(double buoyancy) + { + m_host.AddScriptLPS(1); + if (m_host.ParentGroup != null) + { + if (m_host.ParentGroup.RootPart != null) + { + m_host.ParentGroup.RootPart.SetBuoyancy((float)buoyancy); + } + } + } + + + + public void llSetHoverHeight(double height, int water, double tau) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetHoverHeight"); + } + + public void llStopHover() + { + m_host.AddScriptLPS(1); + NotImplemented("llStopHover"); + } + + public void llMinEventDelay(double delay) + { + m_host.AddScriptLPS(1); + NotImplemented("llMinEventDelay"); + } + + public void llSoundPreload() + { + m_host.AddScriptLPS(1); + NotImplemented("llSoundPreload"); + } + + public void llRotLookAt(LSL_Types.Quaternion target, double strength, double damping) + { + m_host.AddScriptLPS(1); + NotImplemented("llRotLookAt"); + } + + public LSL_Types.LSLInteger llStringLength(string str) + { + m_host.AddScriptLPS(1); + if (str.Length > 0) + { + return str.Length; + } + else + { + return 0; + } + } + + public void llStartAnimation(string anim) + { + m_host.AddScriptLPS(1); + + LLUUID invItemID=InventorySelf(); + if (invItemID == LLUUID.Zero) + return; + + if (m_host.TaskInventory[invItemID].PermsGranter == LLUUID.Zero) + return; + + if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_TRIGGER_ANIMATION) != 0) + { + ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[invItemID].PermsGranter); + + if (presence != null) + { + // Do NOT try to parse LLUUID, animations cannot be triggered by ID + LLUUID animID=InventoryKey(anim, (int)AssetType.Animation); + if (animID == LLUUID.Zero) + presence.AddAnimation(anim); + else + presence.AddAnimation(animID); + } + } + } + + public void llStopAnimation(string anim) + { + m_host.AddScriptLPS(1); + + LLUUID invItemID=InventorySelf(); + if (invItemID == LLUUID.Zero) + return; + + if (m_host.TaskInventory[invItemID].PermsGranter == LLUUID.Zero) + return; + + if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_TRIGGER_ANIMATION) != 0) + { + LLUUID animID = new LLUUID(); + + if (!LLUUID.TryParse(anim, out animID)) + { + animID=InventoryKey(anim); + } + + if (animID == LLUUID.Zero) + return; + + ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[invItemID].PermsGranter); + + if (presence != null) + { + if (animID == LLUUID.Zero) + presence.RemoveAnimation(anim); + else + presence.RemoveAnimation(animID); + } + } + } + + public void llPointAt() + { + m_host.AddScriptLPS(1); + NotImplemented("llPointAt"); + } + + public void llStopPointAt() + { + m_host.AddScriptLPS(1); + NotImplemented("llStopPointAt"); + } + + public void llTargetOmega(LSL_Types.Vector3 axis, double spinrate, double gain) + { + m_host.AddScriptLPS(1); + m_host.RotationalVelocity = new LLVector3((float)(axis.x * spinrate), (float)(axis.y * spinrate), (float)(axis.z * spinrate)); + m_host.AngularVelocity = new LLVector3((float)(axis.x * spinrate), (float)(axis.y * spinrate), (float)(axis.z * spinrate)); + m_host.ScheduleTerseUpdate(); + m_host.SendTerseUpdateToAllClients(); + } + + public LSL_Types.LSLInteger llGetStartParameter() + { + m_host.AddScriptLPS(1); + // NotImplemented("llGetStartParameter"); + return m_host.ParentGroup.StartParameter; + } + + public void llGodLikeRezObject(string inventory, LSL_Types.Vector3 pos) + { + m_host.AddScriptLPS(1); + NotImplemented("llGodLikeRezObject"); + } + + public void llRequestPermissions(string agent, int perm) + { + LLUUID agentID=new LLUUID(); + + if (!LLUUID.TryParse(agent, out agentID)) + return; + + LLUUID invItemID=InventorySelf(); + + if (invItemID == LLUUID.Zero) + return; // Not in a prim? How?? + + if (agentID == LLUUID.Zero || perm == 0) // Releasing permissions + { + m_host.TaskInventory[invItemID].PermsGranter=LLUUID.Zero; + m_host.TaskInventory[invItemID].PermsMask=0; + + m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams( + "run_time_permissions", new Object[] { + new LSL_Types.LSLInteger(0) }, + new DetectParams[0])); + + return; + } + + m_host.AddScriptLPS(1); + + if (m_host.ParentGroup.RootPart.m_IsAttachment && agent == m_host.ParentGroup.RootPart.m_attachedAvatar) + { + // When attached, certain permissions are implicit if requested from owner + int implicitPerms = ScriptBaseClass.PERMISSION_TAKE_CONTROLS | + ScriptBaseClass.PERMISSION_TRIGGER_ANIMATION | + ScriptBaseClass.PERMISSION_ATTACH; + + if ((perm & (~implicitPerms)) == 0) // Requested only implicit perms + { + m_host.TaskInventory[invItemID].PermsGranter=agentID; + m_host.TaskInventory[invItemID].PermsMask=perm; + + m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams( + "run_time_permissions", new Object[] { + new LSL_Types.LSLInteger(perm) }, + new DetectParams[0])); + + return; + } + } + else if (m_host.m_sitTargetAvatar == agentID) // Sitting avatar + { + // When agent is sitting, certain permissions are implicit if requested from sitting agent + int implicitPerms = ScriptBaseClass.PERMISSION_TRIGGER_ANIMATION | + ScriptBaseClass.PERMISSION_TRACK_CAMERA; + + if ((perm & (~implicitPerms)) == 0) // Requested only implicit perms + { + m_host.TaskInventory[invItemID].PermsGranter=agentID; + m_host.TaskInventory[invItemID].PermsMask=perm; + + m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams( + "run_time_permissions", new Object[] { + new LSL_Types.LSLInteger(perm) }, + new DetectParams[0])); + + return; + } + } + + ScenePresence presence = World.GetScenePresence(agentID); + + if (presence != null) + { + string ownerName=resolveName(m_host.ParentGroup.RootPart.OwnerID); + if (ownerName == String.Empty) + ownerName="(hippos)"; + + if (!m_waitingForScriptAnswer) + { + m_host.TaskInventory[invItemID].PermsGranter=agentID; + m_host.TaskInventory[invItemID].PermsMask=0; + presence.ControllingClient.OnScriptAnswer+=handleScriptAnswer; + m_waitingForScriptAnswer=true; + } + + presence.ControllingClient.SendScriptQuestion(m_host.UUID, m_host.ParentGroup.RootPart.Name, ownerName, invItemID, perm); + return; + } + + // Requested agent is not in range, refuse perms + m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams( + "run_time_permissions", new Object[] { + new LSL_Types.LSLInteger(0) }, + new DetectParams[0])); + } + + void handleScriptAnswer(IClientAPI client, LLUUID taskID, LLUUID itemID, int answer) + { + if (taskID != m_host.UUID) + return; + + LLUUID invItemID=InventorySelf(); + + if (invItemID == LLUUID.Zero) + return; + + client.OnScriptAnswer-=handleScriptAnswer; + m_waitingForScriptAnswer=false; + + m_host.TaskInventory[invItemID].PermsMask=answer; + m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams( + "run_time_permissions", new Object[] { + new LSL_Types.LSLInteger(answer) }, + new DetectParams[0])); + } + + public string llGetPermissionsKey() + { + m_host.AddScriptLPS(1); + + foreach (TaskInventoryItem item in m_host.TaskInventory.Values) + { + if (item.Type == 10 && item.ItemID == m_itemID) + { + return item.PermsGranter.ToString(); + } + } + + return LLUUID.Zero.ToString(); + } + + public LSL_Types.LSLInteger llGetPermissions() + { + m_host.AddScriptLPS(1); + + foreach (TaskInventoryItem item in m_host.TaskInventory.Values) + { + if (item.Type == 10 && item.ItemID == m_itemID) + { + return item.PermsMask; + } + } + + return 0; + } + + public LSL_Types.LSLInteger llGetLinkNumber() + { + m_host.AddScriptLPS(1); + + if (m_host.ParentGroup.Children.Count > 0) + { + return m_host.LinkNum + 1; + } + else + { + return 0; + } + } + + public void llSetLinkColor(int linknumber, LSL_Types.Vector3 color, int face) + { + m_host.AddScriptLPS(1); + SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknumber); + if (linknumber > -1) + { + LLObject.TextureEntry tex = part.Shape.Textures; + LLColor texcolor; + if (face > -1) + { + texcolor = tex.CreateFace((uint)face).RGBA; + texcolor.R = (float)Math.Abs(color.x - 1); + texcolor.G = (float)Math.Abs(color.y - 1); + texcolor.B = (float)Math.Abs(color.z - 1); + tex.FaceTextures[face].RGBA = texcolor; + part.UpdateTexture(tex); + return; + } + else if (face == -1) + { + texcolor = tex.DefaultTexture.RGBA; + texcolor.R = (float)Math.Abs(color.x - 1); + texcolor.G = (float)Math.Abs(color.y - 1); + texcolor.B = (float)Math.Abs(color.z - 1); + tex.DefaultTexture.RGBA = texcolor; + for (uint i = 0; i < 32; i++) + { + if (tex.FaceTextures[i] != null) + { + texcolor = tex.FaceTextures[i].RGBA; + texcolor.R = (float)Math.Abs(color.x - 1); + texcolor.G = (float)Math.Abs(color.y - 1); + texcolor.B = (float)Math.Abs(color.z - 1); + tex.FaceTextures[i].RGBA = texcolor; + } + } + texcolor = tex.DefaultTexture.RGBA; + texcolor.R = (float)Math.Abs(color.x - 1); + texcolor.G = (float)Math.Abs(color.y - 1); + texcolor.B = (float)Math.Abs(color.z - 1); + tex.DefaultTexture.RGBA = texcolor; + part.UpdateTexture(tex); + return; + } + return; + } + else if (linknumber == -1) + { + int num = m_host.ParentGroup.PrimCount; + for (int w = 0; w < num; w++) + { + linknumber = w; + part = m_host.ParentGroup.GetLinkNumPart(linknumber); + LLObject.TextureEntry tex = part.Shape.Textures; + LLColor texcolor; + if (face > -1) + { + texcolor = tex.CreateFace((uint)face).RGBA; + texcolor.R = (float)Math.Abs(color.x - 1); + texcolor.G = (float)Math.Abs(color.y - 1); + texcolor.B = (float)Math.Abs(color.z - 1); + tex.FaceTextures[face].RGBA = texcolor; + part.UpdateTexture(tex); + } + else if (face == -1) + { + texcolor = tex.DefaultTexture.RGBA; + texcolor.R = (float)Math.Abs(color.x - 1); + texcolor.G = (float)Math.Abs(color.y - 1); + texcolor.B = (float)Math.Abs(color.z - 1); + tex.DefaultTexture.RGBA = texcolor; + for (uint i = 0; i < 32; i++) + { + if (tex.FaceTextures[i] != null) + { + texcolor = tex.FaceTextures[i].RGBA; + texcolor.R = (float)Math.Abs(color.x - 1); + texcolor.G = (float)Math.Abs(color.y - 1); + texcolor.B = (float)Math.Abs(color.z - 1); + tex.FaceTextures[i].RGBA = texcolor; + } + } + texcolor = tex.DefaultTexture.RGBA; + texcolor.R = (float)Math.Abs(color.x - 1); + texcolor.G = (float)Math.Abs(color.y - 1); + texcolor.B = (float)Math.Abs(color.z - 1); + tex.DefaultTexture.RGBA = texcolor; + part.UpdateTexture(tex); + } + } + return; + } + } + + public void llCreateLink(string target, int parent) + { + m_host.AddScriptLPS(1); + NotImplemented("llCreateLink"); + } + + public void llBreakLink(int linknum) + { + m_host.AddScriptLPS(1); + NotImplemented("llBreakLink"); + } + + public void llBreakAllLinks() + { + m_host.AddScriptLPS(1); + NotImplemented("llBreakAllLinks"); + } + + public string llGetLinkKey(int linknum) + { + m_host.AddScriptLPS(1); + SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknum); + if (part != null) + { + return part.UUID.ToString(); + } + else + { + return LLUUID.Zero.ToString(); + } + } + + public string llGetLinkName(int linknum) + { + m_host.AddScriptLPS(1); + SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknum); + if (part != null) + { + return part.Name; + } + else + { + return LLUUID.Zero.ToString(); + } + } + + public LSL_Types.LSLInteger llGetInventoryNumber(int type) + { + m_host.AddScriptLPS(1); + int count = 0; + foreach (KeyValuePair inv in m_host.TaskInventory) + { + if (inv.Value.Type == type || type == -1) + { + count = count + 1; + } + } + return count; + } + + public string llGetInventoryName(int type, int number) + { + m_host.AddScriptLPS(1); + ArrayList keys = new ArrayList(); + foreach (KeyValuePair inv in m_host.TaskInventory) + { + if (inv.Value.Type == type || type == -1) + { + keys.Add(inv.Value.Name); + } + } + if (keys.Count == 0) + { + return String.Empty; + } + keys.Sort(); + if (keys.Count > number) + { + return (string)keys[number]; + } + return String.Empty; + } + + public void llSetScriptState(string name, int run) + { + LLUUID item; + + m_host.AddScriptLPS(1); + + // These functions are supposed to be robust, + // so get the state one step at a time. + + if ((item = ScriptByName(name)) != LLUUID.Zero) + { + m_ScriptEngine.SetScriptState(item, run == 0 ? false : true); + } + else + { + ShoutError("llSetScriptState: script "+name+" not found"); + } + } + + public double llGetEnergy() + { + m_host.AddScriptLPS(1); + // TODO: figure out real energy value + return 1.0f; + } + + public void llGiveInventory(string destination, string inventory) + { + m_host.AddScriptLPS(1); + NotImplemented("llGiveInventory"); + } + + public void llRemoveInventory(string item) + { + m_host.AddScriptLPS(1); + NotImplemented("llRemoveInventory"); + } + + public void llSetText(string text, LSL_Types.Vector3 color, double alpha) + { + m_host.AddScriptLPS(1); + Vector3 av3 = new Vector3((float)color.x, (float)color.y, (float)color.z); + m_host.SetText(text, av3, alpha); + } + + public double llWater(LSL_Types.Vector3 offset) + { + m_host.AddScriptLPS(1); + return World.RegionInfo.EstateSettings.waterHeight; + } + + public void llPassTouches(int pass) + { + m_host.AddScriptLPS(1); + NotImplemented("llPassTouches"); + } + + public string llRequestAgentData(string id, int data) + { + m_host.AddScriptLPS(1); + + UserProfileData userProfile = + World.CommsManager.UserService.GetUserProfile(id); + + UserAgentData userAgent = + World.CommsManager.UserService.GetAgentByUUID(id); + + if (userProfile == null || userAgent == null) + return LLUUID.Zero.ToString(); + + string reply = String.Empty; + + switch (data) + { + case 1: // DATA_ONLINE (0|1) + // TODO: implement fetching of this information + if (userProfile.CurrentAgent.AgentOnline) + reply = "1"; + else + reply = "0"; + break; + case 2: // DATA_NAME (First Last) + reply = userProfile.FirstName + " " + userProfile.SurName; + break; + case 3: // DATA_BORN (YYYY-MM-DD) + DateTime born = new DateTime(1970, 1, 1, 0, 0, 0, 0); + born = born.AddSeconds(userProfile.Created); + reply = born.ToString("yyyy-MM-dd"); + break; + case 4: // DATA_RATING (0,0,0,0,0,0) + reply = "0,0,0,0,0,0"; + break; + case 8: // DATA_PAYINFO (0|1|2|3) + reply = "0"; + break; + default: + return LLUUID.Zero.ToString(); // Raise no event + } + + LLUUID rq = LLUUID.Random(); + + LLUUID tid = AsyncCommands. + DataserverPlugin.RegisterRequest(m_localID, + m_itemID, rq.ToString()); + + AsyncCommands. + DataserverPlugin.DataserverReply(rq.ToString(), reply); + + return tid.ToString(); + } + + public string llRequestInventoryData(string name) + { + m_host.AddScriptLPS(1); + + foreach (TaskInventoryItem item in m_host.TaskInventory.Values) + { + if (item.Type == 3 && item.Name == name) + { + LLUUID tid = AsyncCommands. + DataserverPlugin.RegisterRequest(m_localID, + m_itemID, item.AssetID.ToString()); + + LLVector3 region = new LLVector3( + World.RegionInfo.RegionLocX * Constants.RegionSize, + World.RegionInfo.RegionLocY * Constants.RegionSize, + 0); + + World.AssetCache.GetAsset(item.AssetID, + delegate(LLUUID i, AssetBase a) + { + AssetLandmark lm = new AssetLandmark(a); + + region += lm.Position; + + string reply = region.ToString(); + + AsyncCommands. + DataserverPlugin.DataserverReply(i.ToString(), + reply); + }, false); + + return tid.ToString(); + } + } + + return String.Empty; + } + + public void llSetDamage(double damage) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetDamage"); + } + + public void llTeleportAgentHome(string agent) + { + m_host.AddScriptLPS(1); + NotImplemented("llTeleportAgentHome"); + } + + public void llModifyLand(int action, int brush) + { + m_host.AddScriptLPS(1); + World.ExternalChecks.ExternalChecksCanTerraformLand(m_host.OwnerID, new LLVector3(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, 0)); + } + + public void llCollisionSound(string impact_sound, double impact_volume) + { + m_host.AddScriptLPS(1); + NotImplemented("llCollisionSound"); + } + + public void llCollisionSprite(string impact_sprite) + { + m_host.AddScriptLPS(1); + NotImplemented("llCollisionSprite"); + } + + public string llGetAnimation(string id) + { + m_host.AddScriptLPS(1); + NotImplemented("llGetAnimation"); + return String.Empty; + } + + public void llResetScript() + { + m_host.AddScriptLPS(1); + m_ScriptEngine.ResetScript(m_itemID); + } + + public void llMessageLinked(int linknum, int num, string msg, string id) + { + + m_host.AddScriptLPS(1); + + uint partLocalID; + LLUUID partItemID; + + switch ((int)linknum) + { + + case (int)ScriptBaseClass.LINK_ROOT: + + SceneObjectPart part = m_host.ParentGroup.RootPart; + + foreach (TaskInventoryItem item in part.TaskInventory.Values) + { + if (item.Type == 10) + { + partLocalID = part.LocalId; + partItemID = item.ItemID; + + object[] resobj = new object[] + { + new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id) + }; + + m_ScriptEngine.PostScriptEvent(partItemID, + new EventParams("link_message", + resobj, new DetectParams[0])); + } + } + + break; + + case (int)ScriptBaseClass.LINK_SET: + + foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts()) + { + + foreach (TaskInventoryItem item in partInst.TaskInventory.Values) + { + if (item.Type == 10) + { + partLocalID = partInst.LocalId; + partItemID = item.ItemID; + Object[] resobj = new object[] + { + new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id) + }; + + m_ScriptEngine.PostScriptEvent(partItemID, + new EventParams("link_message", + resobj, new DetectParams[0])); + } + } + } + + break; + + case (int)ScriptBaseClass.LINK_ALL_OTHERS: + + foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts()) + { + + if (partInst.LocalId != m_host.LocalId) + { + + foreach (TaskInventoryItem item in partInst.TaskInventory.Values) + { + if (item.Type == 10) + { + partLocalID = partInst.LocalId; + partItemID = item.ItemID; + Object[] resobj = new object[] + { + new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id) + }; + + m_ScriptEngine.PostScriptEvent(partItemID, + new EventParams("link_message", + resobj, new DetectParams[0])); + } + } + + } + } + + break; + + case (int)ScriptBaseClass.LINK_ALL_CHILDREN: + + foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts()) + { + + if (partInst.LocalId != m_host.ParentGroup.RootPart.LocalId) + { + + foreach (TaskInventoryItem item in partInst.TaskInventory.Values) + { + if (item.Type == 10) + { + partLocalID = partInst.LocalId; + partItemID = item.ItemID; + Object[] resobj = new object[] + { + new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id) + }; + + m_ScriptEngine.PostScriptEvent(partItemID, + new EventParams("link_message", + resobj, new DetectParams[0])); + } + } + + } + } + + break; + + case (int)ScriptBaseClass.LINK_THIS: + + foreach (TaskInventoryItem item in m_host.TaskInventory.Values) + { + if (item.Type == 10) + { + partItemID = item.ItemID; + + object[] resobj = new object[] + { + new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id) + }; + + m_ScriptEngine.PostScriptEvent(partItemID, + new EventParams("link_message", + resobj, new DetectParams[0])); + } + } + + break; + + default: + + foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts()) + { + + if ((partInst.LinkNum + 1) == linknum) + { + + foreach (TaskInventoryItem item in partInst.TaskInventory.Values) + { + if (item.Type == 10) + { + partLocalID = partInst.LocalId; + partItemID = item.ItemID; + Object[] resObjDef = new object[] + { + new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id) + }; + + m_ScriptEngine.PostScriptEvent(partItemID, + new EventParams("link_message", + resObjDef, new DetectParams[0])); + } + } + + } + } + + break; + + } + + } + + public void llPushObject(string target, LSL_Types.Vector3 impulse, LSL_Types.Vector3 ang_impulse, int local) + { + m_host.AddScriptLPS(1); + NotImplemented("llPushObject"); + } + + public void llPassCollisions(int pass) + { + m_host.AddScriptLPS(1); + NotImplemented("llPassCollisions"); + } + + public string llGetScriptName() + { + + string result = String.Empty; + + m_host.AddScriptLPS(1); + + foreach (TaskInventoryItem item in m_host.TaskInventory.Values) + { + if (item.Type == 10 && item.ItemID == m_itemID) + { + result = item.Name!=null?item.Name:String.Empty; + break; + } + } + + return result; + + } + + public LSL_Types.LSLInteger llGetNumberOfSides() + { + m_host.AddScriptLPS(1); + NotImplemented("llGetNumberOfSides"); + return 0; + } + + + /* The new / changed functions were tested with the following LSL script: + + default + { + state_entry() + { + rotation rot = llEuler2Rot(<0,70,0> * DEG_TO_RAD); + + llOwnerSay("to get here, we rotate over: "+ (string) llRot2Axis(rot)); + llOwnerSay("and we rotate for: "+ (llRot2Angle(rot) * RAD_TO_DEG)); + + // convert back and forth between quaternion <-> vector and angle + + rotation newrot = llAxisAngle2Rot(llRot2Axis(rot),llRot2Angle(rot)); + + llOwnerSay("Old rotation was: "+(string) rot); + llOwnerSay("re-converted rotation is: "+(string) newrot); + + llSetRot(rot); // to check the parameters in the prim + } + } + */ + + + + // Xantor 29/apr/2008 + // Returns rotation described by rotating angle radians about axis. + // q = cos(a/2) + i (x * sin(a/2)) + j (y * sin(a/2)) + k (z * sin(a/2)) + public LSL_Types.Quaternion llAxisAngle2Rot(LSL_Types.Vector3 axis, double angle) + { + m_host.AddScriptLPS(1); + + double x, y, z, s, t; + + s = Math.Cos(angle / 2); + t = Math.Sin(angle / 2); // temp value to avoid 2 more sin() calcs + x = axis.x * t; + y = axis.y * t; + z = axis.z * t; + + return new LSL_Types.Quaternion(x,y,z,s); + } + + + // Xantor 29/apr/2008 + // converts a Quaternion to X,Y,Z axis rotations + public LSL_Types.Vector3 llRot2Axis(LSL_Types.Quaternion rot) + { + m_host.AddScriptLPS(1); + double x,y,z; + + if (rot.s > 1) // normalization needed + { + double length = Math.Sqrt(rot.x * rot.x + rot.y * rot.y + + rot.z * rot.z + rot.s * rot.s); + + rot.x /= length; + rot.y /= length; + rot.z /= length; + rot.s /= length; + + } + + double angle = 2 * Math.Acos(rot.s); + double s = Math.Sqrt(1 - rot.s * rot.s); + if (s < 0.001) + { + x = 1; + y = z = 0; + } + else + { + x = rot.x / s; // normalise axis + y = rot.y / s; + z = rot.z / s; + } + + + return new LSL_Types.Vector3(x,y,z); + + +// NotImplemented("llRot2Axis"); + } + + + // Returns the angle of a quaternion (see llRot2Axis for the axis) + public double llRot2Angle(LSL_Types.Quaternion rot) + { + m_host.AddScriptLPS(1); + + if (rot.s > 1) // normalization needed + { + double length = Math.Sqrt(rot.x * rot.x + rot.y * rot.y + + rot.z * rot.z + rot.s * rot.s); + + rot.x /= length; + rot.y /= length; + rot.z /= length; + rot.s /= length; + + } + + double angle = 2 * Math.Acos(rot.s); + + return angle; + +// NotImplemented("llRot2Angle"); + } + + public double llAcos(double val) + { + m_host.AddScriptLPS(1); + return (double)Math.Acos(val); + } + + public double llAsin(double val) + { + m_host.AddScriptLPS(1); + return (double)Math.Asin(val); + } + + // Xantor 30/apr/2008 + public double llAngleBetween(LSL_Types.Quaternion a, LSL_Types.Quaternion b) + { + m_host.AddScriptLPS(1); + + return (double) Math.Acos(a.x * b.x + a.y * b.y + a.z * b.z + a.s * b.s) * 2; + } + + public string llGetInventoryKey(string name) + { + m_host.AddScriptLPS(1); + foreach (KeyValuePair inv in m_host.TaskInventory) + { + if (inv.Value.Name == name) + { + if ((inv.Value.OwnerMask & (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify)) == (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify)) + { + return inv.Value.AssetID.ToString(); + } + else + { + return LLUUID.Zero.ToString(); + } + } + } + return LLUUID.Zero.ToString(); + } + + public void llAllowInventoryDrop(int add) + { + m_host.AddScriptLPS(1); + NotImplemented("llAllowInventoryDrop"); + } + + public LSL_Types.Vector3 llGetSunDirection() + { + m_host.AddScriptLPS(1); + + LSL_Types.Vector3 SunDoubleVector3; + LLVector3 SunFloatVector3; + + // sunPosition estate setting is set in OpenSim.Region.Environment.Modules.SunModule + // have to convert from LLVector3 (float) to LSL_Types.Vector3 (double) + SunFloatVector3 = World.RegionInfo.EstateSettings.sunPosition; + SunDoubleVector3.x = (double)SunFloatVector3.X; + SunDoubleVector3.y = (double)SunFloatVector3.Y; + SunDoubleVector3.z = (double)SunFloatVector3.Z; + + return SunDoubleVector3; + } + + public LSL_Types.Vector3 llGetTextureOffset(int face) + { + m_host.AddScriptLPS(1); + LLObject.TextureEntry tex = m_host.Shape.Textures; + LSL_Types.Vector3 offset; + if (face == -1) + { + face = 0; + } + offset.x = tex.GetFace((uint)face).OffsetU; + offset.y = tex.GetFace((uint)face).OffsetV; + offset.z = 0.0; + return offset; + } + + public LSL_Types.Vector3 llGetTextureScale(int side) + { + m_host.AddScriptLPS(1); + LLObject.TextureEntry tex = m_host.Shape.Textures; + LSL_Types.Vector3 scale; + if (side == -1) + { + side = 0; + } + scale.x = tex.GetFace((uint)side).RepeatU; + scale.y = tex.GetFace((uint)side).RepeatV; + scale.z = 0.0; + return scale; + } + + public double llGetTextureRot(int face) + { + m_host.AddScriptLPS(1); + LLObject.TextureEntry tex = m_host.Shape.Textures; + if (face == -1) + { + face = 0; + } + return tex.GetFace((uint)face).Rotation; + } + + public LSL_Types.LSLInteger llSubStringIndex(string source, string pattern) + { + m_host.AddScriptLPS(1); + return source.IndexOf(pattern); + } + + public string llGetOwnerKey(string id) + { + m_host.AddScriptLPS(1); + LLUUID key = new LLUUID(); + if (LLUUID.TryParse(id, out key)) + { + return World.GetSceneObjectPart(World.Entities[key].LocalId).OwnerID.ToString(); + } + else + { + return LLUUID.Zero.ToString(); + } + } + + public LSL_Types.Vector3 llGetCenterOfMass() + { + m_host.AddScriptLPS(1); + NotImplemented("llGetCenterOfMass"); + return new LSL_Types.Vector3(); + } + + public LSL_Types.list llListSort(LSL_Types.list src, int stride, int ascending) + { + m_host.AddScriptLPS(1); + return src.Sort(stride, ascending); + } + + public LSL_Types.LSLInteger llGetListLength(LSL_Types.list src) + { + m_host.AddScriptLPS(1); + return src.Length; + } + + public LSL_Types.LSLInteger llList2Integer(LSL_Types.list src, int index) + { + m_host.AddScriptLPS(1); + if (index < 0) + { + index = src.Length + index; + } + if (index >= src.Length) + { + return 0; + } + try + { + return Convert.ToInt32(src.Data[index]); + } + catch (FormatException) + { + return 0; + } + } + + public double osList2Double(LSL_Types.list src, int index) + { + m_host.AddScriptLPS(1); + if (index < 0) + { + index = src.Length + index; + } + if (index >= src.Length) + { + return 0.0; + } + return Convert.ToDouble(src.Data[index]); + } + + public double llList2Float(LSL_Types.list src, int index) + { + m_host.AddScriptLPS(1); + if (index < 0) + { + index = src.Length + index; + } + if (index >= src.Length) + { + return 0.0; + } + try + { + return Convert.ToDouble(src.Data[index]); + } + catch (FormatException) + { + return 0.0; + } + } + + public string llList2String(LSL_Types.list src, int index) + { + m_host.AddScriptLPS(1); + if (index < 0) + { + index = src.Length + index; + } + if (index >= src.Length) + { + return String.Empty; + } + return src.Data[index].ToString(); + } + + public string llList2Key(LSL_Types.list src, int index) + { + m_host.AddScriptLPS(1); + if (index < 0) + { + index = src.Length + index; + } + if (index >= src.Length) + { + return ""; + } + return src.Data[index].ToString(); + } + + public LSL_Types.Vector3 llList2Vector(LSL_Types.list src, int index) + { + m_host.AddScriptLPS(1); + if (index < 0) + { + index = src.Length + index; + } + if (index >= src.Length) + { + return new LSL_Types.Vector3(0, 0, 0); + } + if (src.Data[index].GetType() == typeof(LSL_Types.Vector3)) + { + return (LSL_Types.Vector3)src.Data[index]; + } + else + { + return new LSL_Types.Vector3(src.Data[index].ToString()); + } + } + + public LSL_Types.Quaternion llList2Rot(LSL_Types.list src, int index) + { + m_host.AddScriptLPS(1); + if (index < 0) + { + index = src.Length + index; + } + if (index >= src.Length) + { + return new LSL_Types.Quaternion(0, 0, 0, 1); + } + if (src.Data[index].GetType() == typeof(LSL_Types.Quaternion)) + { + return (LSL_Types.Quaternion)src.Data[index]; + } + else + { + return new LSL_Types.Quaternion(src.Data[index].ToString()); + } + } + + public LSL_Types.list llList2List(LSL_Types.list src, int start, int end) + { + m_host.AddScriptLPS(1); + return src.GetSublist(start, end); + } + + public LSL_Types.list llDeleteSubList(LSL_Types.list src, int start, int end) + { + return src.DeleteSublist(end, start); + } + + public LSL_Types.LSLInteger llGetListEntryType(LSL_Types.list src, int index) + { + m_host.AddScriptLPS(1); + if (index < 0) + { + index = src.Length + index; + } + if (index >= src.Length) + { + return 0; + } + + if (src.Data[index] is Int32) + return 1; + if (src.Data[index] is Double) + return 2; + if (src.Data[index] is String) + { + LLUUID tuuid; + if (LLUUID.TryParse(src.Data[index].ToString(), out tuuid)) + { + return 3; + } + else + { + return 4; + } + } + if (src.Data[index] is LSL_Types.Vector3) + return 5; + if (src.Data[index] is LSL_Types.Quaternion) + return 6; + if (src.Data[index] is LSL_Types.list) + return 7; + return 0; + + } + + /// + /// Process the supplied list and return the + /// content of the list formatted as a comma + /// separated list. There is a space after + /// each comma. + /// + + public string llList2CSV(LSL_Types.list src) + { + + string ret = String.Empty; + int x = 0; + + m_host.AddScriptLPS(1); + + if (src.Data.Length > 0) + { + ret = src.Data[x++].ToString(); + for (; x < src.Data.Length; x++) + { + ret += ", "+src.Data[x].ToString(); + } + } + + return ret; + } + + /// + /// The supplied string is scanned for commas + /// and converted into a list. Commas are only + /// effective if they are encountered outside + /// of '<' '>' delimiters. Any whitespace + /// before or after an element is trimmed. + /// + + public LSL_Types.list llCSV2List(string src) + { + + LSL_Types.list result = new LSL_Types.list(); + int parens = 0; + int start = 0; + int length = 0; + + m_host.AddScriptLPS(1); + + for (int i = 0; i < src.Length; i++) + { + switch (src[i]) + { + case '<': + parens++; + length++; + break; + case '>': + if (parens > 0) + parens--; + length++; + break; + case ',': + if (parens == 0) + { + result.Add(src.Substring(start,length).Trim()); + start += length+1; + length = 0; + } + else + { + length++; + } + break; + default: + length++; + break; + } + } + + result.Add(src.Substring(start,length).Trim()); + + return result; + } + + /// + /// Randomizes the list, be arbitrarily reordering + /// sublists of stride elements. As the stride approaches + /// the size of the list, the options become very + /// limited. + /// + /// + /// This could take a while for very large list + /// sizes. + /// + + public LSL_Types.list llListRandomize(LSL_Types.list src, int stride) + { + + LSL_Types.list result; + Random rand = new Random(); + + int chunkk; + int[] chunks; + int index1; + int index2; + int tmp; + + m_host.AddScriptLPS(1); + + if (stride == 0) + stride = 1; + + // Stride MUST be a factor of the list length + // If not, then return the src list. This also + // traps those cases where stride > length. + + if (src.Length != stride && src.Length%stride == 0) + { + chunkk = src.Length/stride; + + chunks = new int[chunkk]; + + for (int i = 0; i < chunkk; i++) + chunks[i] = i; + + for (int i = 0; i < chunkk - 1; i++) + { + // randomly select 2 chunks + index1 = rand.Next(rand.Next(65536)); + index1 = index1%chunkk; + index2 = rand.Next(rand.Next(65536)); + index2 = index2%chunkk; + + // and swap their relative positions + tmp = chunks[index1]; + chunks[index1] = chunks[index2]; + chunks[index2] = tmp; + } + + // Construct the randomized list + + result = new LSL_Types.list(); + + for (int i = 0; i < chunkk; i++) + { + for (int j = 0; j < stride; j++) + { + result.Add(src.Data[chunks[i]*stride+j]); + } + } + } + else { + object[] array = new object[src.Length]; + Array.Copy(src.Data, 0, array, 0, src.Length); + result = new LSL_Types.list(array); + } + + return result; + + } + + /// + /// Elements in the source list starting with 0 and then + /// every i+stride. If the stride is negative then the scan + /// is backwards producing an inverted result. + /// Only those elements that are also in the specified + /// range are included in the result. + /// + + public LSL_Types.list llList2ListStrided(LSL_Types.list src, int start, int end, int stride) + { + + LSL_Types.list result = new LSL_Types.list(); + int[] si = new int[2]; + int[] ei = new int[2]; + bool twopass = false; + + m_host.AddScriptLPS(1); + + // First step is always to deal with negative indices + + if (start < 0) + start = src.Length+start; + if (end < 0) + end = src.Length+end; + + // Out of bounds indices are OK, just trim them + // accordingly + + if (start > src.Length) + start = src.Length; + + if (end > src.Length) + end = src.Length; + + // There may be one or two ranges to be considered + + if (start != end) + { + + if (start <= end) + { + si[0] = start; + ei[0] = end; + } + else + { + si[1] = start; + ei[1] = src.Length; + si[0] = 0; + ei[0] = end; + twopass = true; + } + + // The scan always starts from the beginning of the + // source list, but members are only selected if they + // fall within the specified sub-range. The specified + // range values are inclusive. + // A negative stride reverses the direction of the + // scan producing an inverted list as a result. + + if (stride == 0) + stride = 1; + + if (stride > 0) + { + for (int i = 0; i < src.Length; i += stride) + { + if (i<=ei[0] && i>=si[0]) + result.Add(src.Data[i]); + if (twopass && i>=si[1] && i<=ei[1]) + result.Add(src.Data[i]); + } + } + else if (stride < 0) + { + for (int i = src.Length - 1; i >= 0; i += stride) + { + if (i <= ei[0] && i >= si[0]) + result.Add(src.Data[i]); + if (twopass && i >= si[1] && i <= ei[1]) + result.Add(src.Data[i]); + } + } + } + + return result; + } + + public LSL_Types.Vector3 llGetRegionCorner() + { + m_host.AddScriptLPS(1); + return new LSL_Types.Vector3(World.RegionInfo.RegionLocX * Constants.RegionSize, World.RegionInfo.RegionLocY * Constants.RegionSize, 0); + } + + /// + /// Insert the list identified by into the + /// list designated by such that the first + /// new element has the index specified by + /// + + public LSL_Types.list llListInsertList(LSL_Types.list dest, LSL_Types.list src, int index) + { + + LSL_Types.list pref = null; + LSL_Types.list suff = null; + + m_host.AddScriptLPS(1); + + if (index < 0) + { + index = index+dest.Length; + if (index < 0) + { + index = 0; + } + } + + if (index != 0) + { + pref = dest.GetSublist(0,index-1); + if (index < dest.Length) + { + suff = dest.GetSublist(index,-1); + return pref + src + suff; + } + else + { + return pref + src; + } + } + else + { + if (index < dest.Length) + { + suff = dest.GetSublist(index,-1); + return src + suff; + } + else + { + return src; + } + } + + } + + /// + /// Returns the index of the first occurrence of test + /// in src. + /// + + public LSL_Types.LSLInteger llListFindList(LSL_Types.list src, LSL_Types.list test) + { + + int index = -1; + int length = src.Length - test.Length + 1; + + m_host.AddScriptLPS(1); + + // If either list is empty, do not match + + if (src.Length != 0 && test.Length != 0) + { + for (int i = 0; i < length; i++) + { + if (src.Data[i].Equals(test.Data[0])) + { + int j; + for (j = 1; j < test.Length; j++) + if (!src.Data[i+j].Equals(test.Data[j])) + break; + if (j == test.Length) + { + index = i; + break; + } + } + } + } + + return index; + + } + + public string llGetObjectName() + { + m_host.AddScriptLPS(1); + return m_host.Name!=null?m_host.Name:String.Empty; + } + + public void llSetObjectName(string name) + { + m_host.AddScriptLPS(1); + m_host.Name = name!=null?name:String.Empty; + } + + public string llGetDate() + { + m_host.AddScriptLPS(1); + DateTime date = DateTime.Now.ToUniversalTime(); + string result = date.ToString("yyyy-MM-dd"); + return result; + } + + public LSL_Types.LSLInteger llEdgeOfWorld(LSL_Types.Vector3 pos, LSL_Types.Vector3 dir) + { + m_host.AddScriptLPS(1); + NotImplemented("llEdgeOfWorld"); + return 0; + } + + public LSL_Types.LSLInteger llGetAgentInfo(string id) + { + m_host.AddScriptLPS(1); + NotImplemented("llGetAgentInfo"); + return 0; + } + + public void llAdjustSoundVolume(double volume) + { + m_host.AddScriptLPS(1); + m_host.AdjustSoundGain(volume); + } + + public void llSetSoundQueueing(int queue) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetSoundQueueing"); + } + + public void llSetSoundRadius(double radius) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetSoundRadius"); + } + + public string llKey2Name(string id) + { + m_host.AddScriptLPS(1); + LLUUID key = new LLUUID(); + if (LLUUID.TryParse(id,out key)) + { + ScenePresence presence = World.GetScenePresence(key); + + if (presence != null) + { + return presence.ControllingClient.Name; + //return presence.Name; + } + + if (World.GetSceneObjectPart(key) != null) + { + return World.GetSceneObjectPart(key).Name; + } + } + return String.Empty; + } + + + + public void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate) + { + m_host.AddScriptLPS(1); + Primitive.TextureAnimation pTexAnim = new Primitive.TextureAnimation(); + pTexAnim.Flags =(uint) mode; + + //ALL_SIDES + if (face == -1) + face = 255; + + pTexAnim.Face = (uint)face; + pTexAnim.Length = (float)length; + pTexAnim.Rate = (float)rate; + pTexAnim.SizeX = (uint)sizex; + pTexAnim.SizeY = (uint)sizey; + pTexAnim.Start = (float)start; + + m_host.AddTextureAnimation(pTexAnim); + m_host.SendFullUpdateToAllClients(); + } + + public void llTriggerSoundLimited(string sound, double volume, LSL_Types.Vector3 top_north_east, + LSL_Types.Vector3 bottom_south_west) + { + m_host.AddScriptLPS(1); + NotImplemented("llTriggerSoundLimited"); + } + + public void llEjectFromLand(string pest) + { + m_host.AddScriptLPS(1); + NotImplemented("llEjectFromLand"); + } + + public LSL_Types.list llParseString2List(string str, LSL_Types.list separators, LSL_Types.list spacers) + { + m_host.AddScriptLPS(1); + LSL_Types.list ret = new LSL_Types.list(); + object[] delimiters = new object[separators.Length + spacers.Length]; + separators.Data.CopyTo(delimiters, 0); + spacers.Data.CopyTo(delimiters, separators.Length); + bool dfound = false; + do + { + dfound = false; + int cindex = -1; + string cdeli = ""; + for (int i = 0; i < delimiters.Length; i++) + { + int index = str.IndexOf(delimiters[i].ToString()); + bool found = index != -1; + if (found) + { + if ((cindex > index) || (cindex == -1)) + { + cindex = index; + cdeli = (string)delimiters[i]; + } + dfound = dfound || found; + } + } + if (cindex != -1) + { + if (cindex > 0) + { + ret.Add(str.Substring(0, cindex)); + if (spacers.Contains(cdeli)) + { + ret.Add(cdeli); + } + } + if (cindex == 0 && spacers.Contains(cdeli)) + { + ret.Add(cdeli); + } + str = str.Substring(cindex + cdeli.Length); + } + } while (dfound); + if (str != "") + { + ret.Add(str); + } + return ret; + } + + public LSL_Types.LSLInteger llOverMyLand(string id) + { + + m_host.AddScriptLPS(1); + LLUUID key = new LLUUID(); + if (LLUUID.TryParse(id,out key)) + { + SceneObjectPart obj = new SceneObjectPart(); + obj = World.GetSceneObjectPart(World.Entities[key].LocalId); + if (obj.OwnerID == World.GetLandOwner(obj.AbsolutePosition.X, obj.AbsolutePosition.Y)) + { + return 1; + } + else + { + return 0; + } + } + else + { + return 0; + } + } + + public string llGetLandOwnerAt(LSL_Types.Vector3 pos) + { + m_host.AddScriptLPS(1); + return World.GetLandOwner((float)pos.x, (float)pos.y).ToString(); + } + + public LSL_Types.Vector3 llGetAgentSize(string id) + { + m_host.AddScriptLPS(1); + NotImplemented("llGetAgentSize"); + return new LSL_Types.Vector3(); + } + + public LSL_Types.LSLInteger llSameGroup(string agent) + { + m_host.AddScriptLPS(1); + NotImplemented("llSameGroup"); + return 0; + } + + public void llUnSit(string id) + { + m_host.AddScriptLPS(1); + + LLUUID key = new LLUUID(); + if (LLUUID.TryParse(id, out key)) + { + ScenePresence av = World.GetScenePresence(key); + + if (av != null) + { + if (llAvatarOnSitTarget() == id) + { + // if the avatar is sitting on this object, then + // we can unsit them. We don't want random scripts unsitting random people + // Lets avoid the popcorn avatar scenario. + av.StandUp(); + } + else + { + // If the object owner also owns the parcel + // or + // if the land is group owned and the object is group owned by the same group + // or + // if the object is owned by a person with estate access. + + ILandObject parcel = World.LandChannel.GetLandObject(av.AbsolutePosition.X, av.AbsolutePosition.Y); + if (parcel != null) + { + if (m_host.ObjectOwner == parcel.landData.ownerID || + (m_host.OwnerID == m_host.GroupID && m_host.GroupID == parcel.landData.groupID + && parcel.landData.isGroupOwned) || World.ExternalChecks.ExternalChecksCanBeGodLike(m_host.OwnerID)) + { + av.StandUp(); + } + } + } + } + + } + + } + + public LSL_Types.Vector3 llGroundSlope(LSL_Types.Vector3 offset) + { + m_host.AddScriptLPS(1); + NotImplemented("llGroundSlope"); + return new LSL_Types.Vector3(); + } + + public LSL_Types.Vector3 llGroundNormal(LSL_Types.Vector3 offset) + { + m_host.AddScriptLPS(1); + NotImplemented("llGroundNormal"); + return new LSL_Types.Vector3(); + } + + public LSL_Types.Vector3 llGroundContour(LSL_Types.Vector3 offset) + { + m_host.AddScriptLPS(1); + NotImplemented("llGroundContour"); + return new LSL_Types.Vector3(); + } + + public LSL_Types.LSLInteger llGetAttached() + { + m_host.AddScriptLPS(1); + NotImplemented("llGetAttached"); + return 0; + } + + public LSL_Types.LSLInteger llGetFreeMemory() + { + m_host.AddScriptLPS(1); + NotImplemented("llGetFreeMemory"); + return 0; + } + + public string llGetRegionName() + { + m_host.AddScriptLPS(1); + return World.RegionInfo.RegionName; + } + + public double llGetRegionTimeDilation() + { + m_host.AddScriptLPS(1); + return (double)World.TimeDilation; + } + + public double llGetRegionFPS() + { + m_host.AddScriptLPS(1); + //TODO: return actual FPS + return 10.0f; + } + + /* particle system rules should be coming into this routine as doubles, that is + rule[0] should be an integer from this list and rule[1] should be the arg + for the same integer. wiki.secondlife.com has most of this mapping, but some + came from http://www.caligari-designs.com/p4u2 + + We iterate through the list for 'Count' elements, incrementing by two for each + iteration and set the members of Primitive.ParticleSystem, one at a time. + */ + + public enum PrimitiveRule : int + { + PSYS_PART_FLAGS = 0, + PSYS_PART_START_COLOR = 1, + PSYS_PART_START_ALPHA = 2, + PSYS_PART_END_COLOR = 3, + PSYS_PART_END_ALPHA = 4, + PSYS_PART_START_SCALE = 5, + PSYS_PART_END_SCALE = 6, + PSYS_PART_MAX_AGE = 7, + PSYS_SRC_ACCEL = 8, + PSYS_SRC_PATTERN = 9, + PSYS_SRC_TEXTURE = 12, + PSYS_SRC_BURST_RATE = 13, + PSYS_SRC_BURST_PART_COUNT = 15, + PSYS_SRC_BURST_RADIUS = 16, + PSYS_SRC_BURST_SPEED_MIN = 17, + PSYS_SRC_BURST_SPEED_MAX = 18, + PSYS_SRC_MAX_AGE = 19, + PSYS_SRC_TARGET_KEY = 20, + PSYS_SRC_OMEGA = 21, + PSYS_SRC_ANGLE_BEGIN = 22, + PSYS_SRC_ANGLE_END = 23 + } + + internal Primitive.ParticleSystem.ParticleDataFlags ConvertUINTtoFlags(uint flags) + { + Primitive.ParticleSystem.ParticleDataFlags returnval = Primitive.ParticleSystem.ParticleDataFlags.None; + + return returnval; + } + + + public void llParticleSystem(LSL_Types.list rules) + { + m_host.AddScriptLPS(1); + Primitive.ParticleSystem prules = new Primitive.ParticleSystem(); + LSL_Types.Vector3 tempv = new LSL_Types.Vector3(); + + float tempf = 0; + + for (int i = 0; i < rules.Length; i += 2) + { + switch ((int)rules.Data[i]) + { + case (int)ScriptBaseClass.PSYS_PART_FLAGS: + prules.PartDataFlags = (Primitive.ParticleSystem.ParticleDataFlags)((uint)Convert.ToInt32(rules.Data[i + 1].ToString())); + break; + + case (int)ScriptBaseClass.PSYS_PART_START_COLOR: + tempv = (LSL_Types.Vector3)rules.Data[i + 1]; + prules.PartStartColor.R = (float)tempv.x; + prules.PartStartColor.G = (float)tempv.y; + prules.PartStartColor.B = (float)tempv.z; + break; + + case (int)ScriptBaseClass.PSYS_PART_START_ALPHA: + tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); + prules.PartStartColor.A = (float)tempf; + break; + + case (int)ScriptBaseClass.PSYS_PART_END_COLOR: + tempv = (LSL_Types.Vector3)rules.Data[i + 1]; + //prules.PartEndColor = new LLColor(tempv.x,tempv.y,tempv.z,1); + + prules.PartEndColor.R = (float)tempv.x; + prules.PartEndColor.G = (float)tempv.y; + prules.PartEndColor.B = (float)tempv.z; + break; + + case (int)ScriptBaseClass.PSYS_PART_END_ALPHA: + tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); + prules.PartEndColor.A = (float)tempf; + break; + + case (int)ScriptBaseClass.PSYS_PART_START_SCALE: + tempv = (LSL_Types.Vector3)rules.Data[i + 1]; + prules.PartStartScaleX = (float)tempv.x; + prules.PartStartScaleY = (float)tempv.y; + break; + + case (int)ScriptBaseClass.PSYS_PART_END_SCALE: + tempv = (LSL_Types.Vector3)rules.Data[i + 1]; + prules.PartEndScaleX = (float)tempv.x; + prules.PartEndScaleY = (float)tempv.y; + break; + + case (int)ScriptBaseClass.PSYS_PART_MAX_AGE: + tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); + prules.PartMaxAge = (float)tempf; + break; + + case (int)ScriptBaseClass.PSYS_SRC_ACCEL: + tempv = (LSL_Types.Vector3)rules.Data[i + 1]; + prules.PartAcceleration.X = (float)tempv.x; + prules.PartAcceleration.Y = (float)tempv.y; + prules.PartAcceleration.Z = (float)tempv.z; + break; + + case (int)ScriptBaseClass.PSYS_SRC_PATTERN: + int tmpi = int.Parse(rules.Data[i + 1].ToString()); + prules.Pattern = (Primitive.ParticleSystem.SourcePattern)tmpi; + break; + + // Xantor 20080503 + // Wiki: PSYS_SRC_TEXTURE string inventory item name or key of the particle texture + // "" = default texture. + // 20080530 Updated to remove code duplication + case (int)ScriptBaseClass.PSYS_SRC_TEXTURE: + prules.Texture = KeyOrName(rules.Data[i + 1].ToString()); + break; + + case (int)ScriptBaseClass.PSYS_SRC_BURST_RATE: + tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); + prules.BurstRate = (float)tempf; + break; + + case (int)ScriptBaseClass.PSYS_SRC_BURST_PART_COUNT: + prules.BurstPartCount = (byte)Convert.ToByte(rules.Data[i + 1].ToString()); + break; + + case (int)ScriptBaseClass.PSYS_SRC_BURST_RADIUS: + tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); + prules.BurstRadius = (float)tempf; + break; + + case (int)ScriptBaseClass.PSYS_SRC_BURST_SPEED_MIN: + tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); + prules.BurstSpeedMin = (float)tempf; + break; + + case (int)ScriptBaseClass.PSYS_SRC_BURST_SPEED_MAX: + tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); + prules.BurstSpeedMax = (float)tempf; + break; + + case (int)ScriptBaseClass.PSYS_SRC_MAX_AGE: + tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); + prules.MaxAge = (float)tempf; + break; + + case (int)ScriptBaseClass.PSYS_SRC_TARGET_KEY: + LLUUID key = LLUUID.Zero; + if (LLUUID.TryParse(rules.Data[i + 1].ToString(), out key)) + { + prules.Target = key; + } + else + { + prules.Target = m_host.UUID; + } + break; + + case (int)ScriptBaseClass.PSYS_SRC_OMEGA: + // AL: This is an assumption, since it is the only thing that would match. + tempv = (LSL_Types.Vector3)rules.Data[i + 1]; + prules.AngularVelocity.X = (float)tempv.x; + prules.AngularVelocity.Y = (float)tempv.y; + prules.AngularVelocity.Z = (float)tempv.z; + //cast?? prules.MaxAge = (float)rules[i + 1]; + break; + + case (int)ScriptBaseClass.PSYS_SRC_ANGLE_BEGIN: + tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); + prules.InnerAngle = (float)tempf; + break; + + case (int)ScriptBaseClass.PSYS_SRC_ANGLE_END: + tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); + prules.OuterAngle = (float)tempf; + break; + } + + } + prules.CRC = 1; + + m_host.AddNewParticleSystem(prules); + m_host.SendFullUpdateToAllClients(); + } + + public void llGroundRepel(double height, int water, double tau) + { + m_host.AddScriptLPS(1); + NotImplemented("llGroundRepel"); + } + + public void llGiveInventoryList(string destination, string category, LSL_Types.list inventory) + { + m_host.AddScriptLPS(1); + NotImplemented("llGiveInventoryList"); + } + + public void llSetVehicleType(int type) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetVehicleType"); + } + + public void llSetVehicledoubleParam(int param, double value) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetVehicledoubleParam"); + } + + public void llSetVehicleFloatParam(int param, float value) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetVehicleFloatParam"); + } + + public void llSetVehicleVectorParam(int param, LSL_Types.Vector3 vec) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetVehicleVectorParam"); + } + + public void llSetVehicleRotationParam(int param, LSL_Types.Quaternion rot) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetVehicleRotationParam"); + } + + public void llSetVehicleFlags(int flags) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetVehicleFlags"); + } + + public void llRemoveVehicleFlags(int flags) + { + m_host.AddScriptLPS(1); + NotImplemented("llRemoveVehicleFlags"); + } + + public void llSitTarget(LSL_Types.Vector3 offset, LSL_Types.Quaternion rot) + { + m_host.AddScriptLPS(1); + // LSL quaternions can normalize to 0, normal Quaternions can't. + if (rot.s == 0 && rot.x == 0 && rot.y == 0 && rot.z == 0) + rot.z = 1; // ZERO_ROTATION = 0,0,0,1 + + m_host.SetSitTarget(new Vector3((float)offset.x, (float)offset.y, (float)offset.z), new Quaternion((float)rot.s, (float)rot.x, (float)rot.y, (float)rot.z)); + } + + public string llAvatarOnSitTarget() + { + m_host.AddScriptLPS(1); + return m_host.GetAvatarOnSitTarget().ToString(); + } + + public void llAddToLandPassList(string avatar, double hours) + { + m_host.AddScriptLPS(1); + LLUUID key; + LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData; + if (land.ownerID == m_host.OwnerID) + { + ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry(); + if (LLUUID.TryParse(avatar, out key)) + { + entry.AgentID = key; + entry.Flags = ParcelManager.AccessList.Access; + entry.Time = DateTime.Now.AddHours(hours); + land.parcelAccessList.Add(entry); + } + } + } + + public void llSetTouchText(string text) + { + m_host.AddScriptLPS(1); + m_host.TouchName = text; + } + + public void llSetSitText(string text) + { + m_host.AddScriptLPS(1); + m_host.SitName = text; + } + + public void llSetCameraEyeOffset(LSL_Types.Vector3 offset) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetCameraEyeOffset"); + } + + public void llSetCameraAtOffset(LSL_Types.Vector3 offset) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetCameraAtOffset"); + } + + public string llDumpList2String(LSL_Types.list src, string seperator) + { + m_host.AddScriptLPS(1); + if (src.Length == 0) + { + return String.Empty; + } + string ret = String.Empty; + foreach (object o in src.Data) + { + ret = ret + o.ToString() + seperator; + } + ret = ret.Substring(0, ret.Length - seperator.Length); + return ret; + } + + public LSL_Types.LSLInteger llScriptDanger(LSL_Types.Vector3 pos) + { + m_host.AddScriptLPS(1); + bool result = World.scriptDanger(m_host.LocalId, new LLVector3((float)pos.x, (float)pos.y, (float)pos.z)); + if (result) + { + return 1; + } + else + { + return 0; + } + + } + + public void llDialog(string avatar, string message, LSL_Types.list buttons, int chat_channel) + { + m_host.AddScriptLPS(1); + LLUUID av = new LLUUID(); + if (!LLUUID.TryParse(avatar,out av)) + { + LSLError("First parameter to llDialog needs to be a key"); + return; + } + if (buttons.Length > 12) + { + LSLError("No more than 12 buttons can be shown"); + return; + } + string[] buts = new string[buttons.Length]; + for (int i = 0; i < buttons.Length; i++) + { + if (buttons.Data[i].ToString() == String.Empty) + { + LSLError("button label cannot be blank"); + return; + } + if (buttons.Data[i].ToString().Length > 24) + { + LSLError("button label cannot be longer than 24 characters"); + return; + } + buts[i] = buttons.Data[i].ToString(); + } + World.SendDialogToUser(av, m_host.Name, m_host.UUID, m_host.OwnerID, message, new LLUUID("00000000-0000-2222-3333-100000001000"), chat_channel, buts); + } + + public void llVolumeDetect(int detect) + { + m_host.AddScriptLPS(1); + NotImplemented("llVolumeDetect"); + } + + /// + /// Reset the named script. The script must be present + /// in the same prim. + /// + + public void llResetOtherScript(string name) + { + LLUUID item; + + m_host.AddScriptLPS(1); + + if ((item = ScriptByName(name)) != LLUUID.Zero) + m_ScriptEngine.ResetScript(item); + else + ShoutError("llResetOtherScript: script "+name+" not found"); + } + + public LSL_Types.LSLInteger llGetScriptState(string name) + { + LLUUID item; + + m_host.AddScriptLPS(1); + + if ((item = ScriptByName(name)) != LLUUID.Zero) + { + return m_ScriptEngine.GetScriptState(item) ?1:0; + } + + ShoutError("llGetScriptState: script "+name+" not found"); + + // If we didn't find it, then it's safe to + // assume it is not running. + + return 0; + } + + public void llRemoteLoadScript() + { + m_host.AddScriptLPS(1); + Deprecated("llRemoteLoadScript"); + } + + public void llSetRemoteScriptAccessPin(int pin) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetRemoteScriptAccessPin"); + } + + public void llRemoteLoadScriptPin(string target, string name, int pin, int running, int start_param) + { + m_host.AddScriptLPS(1); + NotImplemented("llRemoteLoadScriptPin"); + } + + // remote_data(integer type, key channel, key message_id, string sender, integer ival, string sval) + // Not sure where these constants should live: + // REMOTE_DATA_CHANNEL = 1 + // REMOTE_DATA_REQUEST = 2 + // REMOTE_DATA_REPLY = 3 + public void llOpenRemoteDataChannel() + { + m_host.AddScriptLPS(1); + IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface(); + if (xmlrpcMod.IsEnabled()) + { + LLUUID channelID = xmlrpcMod.OpenXMLRPCChannel(m_localID, m_itemID, LLUUID.Zero); + object[] resobj = new object[] { new LSL_Types.LSLInteger(1), new LSL_Types.LSLString(channelID.ToString()), new LSL_Types.LSLString(LLUUID.Zero.ToString()), new LSL_Types.LSLString(String.Empty), new LSL_Types.LSLInteger(0), new LSL_Types.LSLString(String.Empty) }; + m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams( + "remote_data", resobj, + new DetectParams[0])); + } + } + + public string llSendRemoteData(string channel, string dest, int idata, string sdata) + { + m_host.AddScriptLPS(1); + IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface(); + return (xmlrpcMod.SendRemoteData(m_localID, m_itemID, channel, dest, idata, sdata)).ToString(); + } + + public void llRemoteDataReply(string channel, string message_id, string sdata, int idata) + { + m_host.AddScriptLPS(1); + IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface(); + xmlrpcMod.RemoteDataReply(channel, message_id, sdata, idata); + } + + public void llCloseRemoteDataChannel(string channel) + { + m_host.AddScriptLPS(1); + IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface(); + xmlrpcMod.CloseXMLRPCChannel(channel); + } + + public string llMD5String(string src, int nonce) + { + m_host.AddScriptLPS(1); + return Util.Md5Hash(src + ":" + nonce.ToString()); + } + + public void llSetPrimitiveParams(LSL_Types.list rules) + { + llSetLinkPrimitiveParams(m_host.LinkNum+1, rules); + } + + public void llSetLinkPrimitiveParams(int linknumber, LSL_Types.list rules) + { + m_host.AddScriptLPS(1); + + SceneObjectPart part=null; + + if (m_host.LinkNum+1 != linknumber) + { + foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts()) + { + if ((partInst.LinkNum + 1) == linknumber) + { + part = partInst; + break; + } + } + } + else + { + part = m_host; + } + + if (part == null) + return; + + int idx = 0; + + while (idx < rules.Length) + { + int code = Convert.ToInt32(rules.Data[idx++]); + + int remain = rules.Length - idx; + + int face; + LSL_Types.Vector3 v; + + switch (code) + { + case 6: // PRIM_POSITION + if (remain < 1) + return; + + v=new LSL_Types.Vector3(rules.Data[idx++].ToString()); + SetPos(part, v); + + break; + case 7: // PRIM_SIZE + if (remain < 1) + return; + + v=new LSL_Types.Vector3(rules.Data[idx++].ToString()); + SetScale(part, v); + + break; + case 8: // PRIM_ROTATION + if (remain < 1) + return; + + LSL_Types.Quaternion q = new LSL_Types.Quaternion(rules.Data[idx++].ToString()); + SetRot(part, q); + + break; + + case 17: // PRIM_TEXTURE + if (remain < 5) + return; + + face=Convert.ToInt32(rules.Data[idx++]); + string tex=rules.Data[idx++].ToString(); + LSL_Types.Vector3 repeats=new LSL_Types.Vector3(rules.Data[idx++].ToString()); + LSL_Types.Vector3 offsets=new LSL_Types.Vector3(rules.Data[idx++].ToString()); + double rotation=Convert.ToDouble(rules.Data[idx++]); + + SetTexture(part, tex, face); + ScaleTexture(part, repeats.x, repeats.y, face); + OffsetTexture(part, offsets.x, offsets.y, face); + RotateTexture(part, rotation, face); + + break; + + case 18: // PRIM_COLOR + if (remain < 3) + return; + + face=Convert.ToInt32(rules.Data[idx++]); + LSL_Types.Vector3 color=new LSL_Types.Vector3(rules.Data[idx++].ToString()); + double alpha=Convert.ToDouble(rules.Data[idx++]); + + SetColor(part, color, face); + SetAlpha(part, alpha, face); + + break; + case 21: // PRIM_FLEXI + if (remain < 7) + return; + + int flexi = Convert.ToInt32(rules.Data[idx++]); + int softness = Convert.ToInt32(rules.Data[idx++]); + float gravity = (float)Convert.ToDouble(rules.Data[idx++]); + float friction = (float)Convert.ToDouble(rules.Data[idx++]); + float wind = (float)Convert.ToDouble(rules.Data[idx++]); + float tension = (float)Convert.ToDouble(rules.Data[idx++]); + LSL_Types.Vector3 force =new LSL_Types.Vector3(rules.Data[idx++].ToString()); + + SetFlexi(part, (flexi == 1), softness, gravity, friction, wind, tension, force); + + break; + case 23: // PRIM_POINT_LIGHT + if (remain < 5) + return; + int light = Convert.ToInt32(rules.Data[idx++]); + LSL_Types.Vector3 lightcolor =new LSL_Types.Vector3(rules.Data[idx++].ToString()); + float intensity = (float)Convert.ToDouble(rules.Data[idx++]); + float radius = (float)Convert.ToDouble(rules.Data[idx++]); + float falloff = (float)Convert.ToDouble(rules.Data[idx++]); + + SetPointLight(part, (light == 1), lightcolor, intensity, radius, falloff); + + break; + } + } + } + + public string llStringToBase64(string str) + { + m_host.AddScriptLPS(1); + try + { + byte[] encData_byte = new byte[str.Length]; + encData_byte = Encoding.UTF8.GetBytes(str); + string encodedData = Convert.ToBase64String(encData_byte); + return encodedData; + } + catch (Exception e) + { + throw new Exception("Error in base64Encode" + e.Message); + } + } + + public string llBase64ToString(string str) + { + m_host.AddScriptLPS(1); + UTF8Encoding encoder = new UTF8Encoding(); + Decoder utf8Decode = encoder.GetDecoder(); + try + { + byte[] todecode_byte = Convert.FromBase64String(str); + int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length); + char[] decoded_char = new char[charCount]; + utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0); + string result = new String(decoded_char); + return result; + } + catch (Exception e) + { + throw new Exception("Error in base64Decode" + e.Message); + } + } + + public void llXorBase64Strings() + { + m_host.AddScriptLPS(1); + Deprecated("llXorBase64Strings"); + } + + public void llRemoteDataSetRegion() + { + m_host.AddScriptLPS(1); + NotImplemented("llRemoteDataSetRegion"); + } + + public double llLog10(double val) + { + m_host.AddScriptLPS(1); + return (double)Math.Log10(val); + } + + public double llLog(double val) + { + m_host.AddScriptLPS(1); + return (double)Math.Log(val); + } + + public LSL_Types.list llGetAnimationList(string id) + { + m_host.AddScriptLPS(1); + NotImplemented("llGetAnimationList"); + return new LSL_Types.list(); + } + + public void llSetParcelMusicURL(string url) + { + m_host.AddScriptLPS(1); + LLUUID landowner = World.GetLandOwner(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y); + if (landowner == LLUUID.Zero) + { + return; + } + if (landowner != m_host.ObjectOwner) + { + return; + } + World.SetLandMusicURL(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, url); + } + + public void osSetParcelMediaURL(string url) + { + m_host.AddScriptLPS(1); + LLUUID landowner = World.GetLandOwner(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y); + + if (landowner == LLUUID.Zero) + { + return; + } + + if (landowner != m_host.ObjectOwner) + { + return; + } + + World.SetLandMediaURL(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, url); + } + + public LSL_Types.Vector3 llGetRootPosition() + { + m_host.AddScriptLPS(1); + return new LSL_Types.Vector3(m_host.ParentGroup.AbsolutePosition.X, m_host.ParentGroup.AbsolutePosition.Y, m_host.ParentGroup.AbsolutePosition.Z); + } + + public LSL_Types.Quaternion llGetRootRotation() + { + m_host.AddScriptLPS(1); + return new LSL_Types.Quaternion(m_host.ParentGroup.GroupRotation.X, m_host.ParentGroup.GroupRotation.Y, m_host.ParentGroup.GroupRotation.Z, m_host.ParentGroup.GroupRotation.W); + } + + public string llGetObjectDesc() + { + return m_host.Description!=null?m_host.Description:String.Empty; + } + + public void llSetObjectDesc(string desc) + { + m_host.AddScriptLPS(1); + m_host.Description = desc!=null?desc:String.Empty; + } + + public string llGetCreator() + { + m_host.AddScriptLPS(1); + return m_host.ObjectCreator.ToString(); + } + + public string llGetTimestamp() + { + m_host.AddScriptLPS(1); + return DateTime.Now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.fffffffZ"); + } + + public void llSetLinkAlpha(int linknumber, double alpha, int face) + { + m_host.AddScriptLPS(1); + SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknumber); + if (linknumber > -1) + { + LLObject.TextureEntry tex = part.Shape.Textures; + LLColor texcolor; + if (face > -1) + { + texcolor = tex.CreateFace((uint)face).RGBA; + texcolor.A = (float)Math.Abs(alpha - 1); + tex.FaceTextures[face].RGBA = texcolor; + part.UpdateTexture(tex); + return; + } + else if (face == -1) + { + texcolor = tex.DefaultTexture.RGBA; + texcolor.A = (float)Math.Abs(alpha - 1); + tex.DefaultTexture.RGBA = texcolor; + for (uint i = 0; i < 32; i++) + { + if (tex.FaceTextures[i] != null) + { + texcolor = tex.FaceTextures[i].RGBA; + texcolor.A = (float)Math.Abs(alpha - 1); + tex.FaceTextures[i].RGBA = texcolor; + } + } + texcolor = tex.DefaultTexture.RGBA; + texcolor.A = (float)Math.Abs(alpha - 1); + tex.DefaultTexture.RGBA = texcolor; + part.UpdateTexture(tex); + return; + } + return; + } + else if (linknumber == -1) + { + int num = m_host.ParentGroup.PrimCount; + for (int w = 0; w < num; w++) + { + linknumber = w; + part = m_host.ParentGroup.GetLinkNumPart(linknumber); + LLObject.TextureEntry tex = part.Shape.Textures; + LLColor texcolor; + if (face > -1) + { + texcolor = tex.CreateFace((uint)face).RGBA; + texcolor.A = (float)Math.Abs(alpha - 1); + tex.FaceTextures[face].RGBA = texcolor; + part.UpdateTexture(tex); + } + else if (face == -1) + { + texcolor = tex.DefaultTexture.RGBA; + texcolor.A = (float)Math.Abs(alpha - 1); + tex.DefaultTexture.RGBA = texcolor; + for (uint i = 0; i < 32; i++) + { + if (tex.FaceTextures[i] != null) + { + texcolor = tex.FaceTextures[i].RGBA; + texcolor.A = (float)Math.Abs(alpha - 1); + tex.FaceTextures[i].RGBA = texcolor; + } + } + texcolor = tex.DefaultTexture.RGBA; + texcolor.A = (float)Math.Abs(alpha - 1); + tex.DefaultTexture.RGBA = texcolor; + part.UpdateTexture(tex); + } + } + return; + } + } + + public LSL_Types.LSLInteger llGetNumberOfPrims() + { + m_host.AddScriptLPS(1); + return m_host.ParentGroup.PrimCount; + } + + public LSL_Types.list llGetBoundingBox(string obj) + { + m_host.AddScriptLPS(1); + NotImplemented("llGetBoundingBox"); + return new LSL_Types.list(); + } + + public LSL_Types.Vector3 llGetGeometricCenter() + { + return new LSL_Types.Vector3(m_host.GetGeometricCenter().X, m_host.GetGeometricCenter().Y, m_host.GetGeometricCenter().Z); + } + + public LSL_Types.list llGetPrimitiveParams(LSL_Types.list rules) + { + m_host.AddScriptLPS(1); + + LSL_Types.list res = new LSL_Types.list(); + int idx=0; + while (idx < rules.Length) + { + int code=Convert.ToInt32(rules.Data[idx++]); + int remain=rules.Length-idx; + + switch (code) + { + case 2: // PRIM_MATERIAL + res.Add(new LSL_Types.LSLInteger(m_host.Material)); + break; + + case 3: // PRIM_PHYSICS + if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Physics) != 0) + res.Add(new LSL_Types.LSLInteger(1)); + else + res.Add(new LSL_Types.LSLInteger(0)); + break; + + case 4: // PRIM_TEMP_ON_REZ + if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.TemporaryOnRez) != 0) + res.Add(new LSL_Types.LSLInteger(1)); + else + res.Add(new LSL_Types.LSLInteger(0)); + break; + + case 5: // PRIM_PHANTOM + if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Phantom) != 0) + res.Add(new LSL_Types.LSLInteger(1)); + else + res.Add(new LSL_Types.LSLInteger(0)); + break; + + case 6: // PRIM_POSITION + res.Add(new LSL_Types.Vector3(m_host.AbsolutePosition.X, + m_host.AbsolutePosition.Y, + m_host.AbsolutePosition.Z)); + break; + + case 7: // PRIM_SIZE + res.Add(new LSL_Types.Vector3(m_host.Scale.X, + m_host.Scale.Y, + m_host.Scale.Z)); + break; + + case 8: // PRIM_ROTATION + res.Add(new LSL_Types.Quaternion(m_host.RotationOffset.X, + m_host.RotationOffset.Y, + m_host.RotationOffset.Z, + m_host.RotationOffset.W)); + break; + + case 9: // PRIM_TYPE + // TODO-------------- + res.Add(new LSL_Types.LSLInteger(0)); + break; + + case 17: // PRIM_TEXTURE + if (remain < 1) + return res; + + int face=Convert.ToInt32(rules.Data[idx++]); + if (face == -1) + face = 0; + + LLObject.TextureEntry tex = m_host.Shape.Textures; + LLObject.TextureEntryFace texface = tex.GetFace((uint)face); + + res.Add(new LSL_Types.LSLString(texface.TextureID.ToString())); + res.Add(new LSL_Types.Vector3(texface.RepeatU, + texface.RepeatV, + 0)); + res.Add(new LSL_Types.Vector3(texface.OffsetU, + texface.OffsetV, + 0)); + res.Add(new LSL_Types.LSLFloat(texface.Rotation)); + break; + + case 18: // PRIM_COLOR + if (remain < 1) + return res; + + face=Convert.ToInt32(rules.Data[idx++]); + + tex = m_host.Shape.Textures; + LLColor texcolor; + if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color + texcolor = tex.DefaultTexture.RGBA; + else + texcolor = tex.GetFace((uint)face).RGBA; + res.Add(new LSL_Types.Vector3((255 - (texcolor.R * 255)) / 255, + (255 - (texcolor.G * 255)) / 255, + (255 - (texcolor.B * 255)) / 255)); + res.Add(new LSL_Types.LSLFloat((texcolor.A * 255) / 255)); + break; + + case 19: // PRIM_BUMP_SHINY + // TODO-------------- + if (remain < 1) + return res; + + face=Convert.ToInt32(rules.Data[idx++]); + + res.Add(new LSL_Types.LSLInteger(0)); + res.Add(new LSL_Types.LSLInteger(0)); + break; + + case 20: // PRIM_FULLBRIGHT + // TODO-------------- + if (remain < 1) + return res; + + face=Convert.ToInt32(rules.Data[idx++]); + + res.Add(new LSL_Types.LSLInteger(0)); + break; + + case 21: // PRIM_FLEXIBLE + PrimitiveBaseShape shape = m_host.Shape; + + if (shape.FlexiEntry) + res.Add(new LSL_Types.LSLInteger(1)); // active + else + res.Add(new LSL_Types.LSLInteger(0)); + res.Add(new LSL_Types.LSLInteger(shape.FlexiSoftness));// softness + res.Add(new LSL_Types.LSLFloat(shape.FlexiGravity)); // gravity + res.Add(new LSL_Types.LSLFloat(shape.FlexiDrag)); // friction + res.Add(new LSL_Types.LSLFloat(shape.FlexiWind)); // wind + res.Add(new LSL_Types.LSLFloat(shape.FlexiTension)); // tension + res.Add(new LSL_Types.Vector3(shape.FlexiForceX, // force + shape.FlexiForceY, + shape.FlexiForceZ)); + break; + + case 22: // PRIM_TEXGEN + // TODO-------------- + // (PRIM_TEXGEN_DEFAULT, PRIM_TEXGEN_PLANAR) + if (remain < 1) + return res; + + face=Convert.ToInt32(rules.Data[idx++]); + + res.Add(new LSL_Types.LSLInteger(0)); + break; + + case 23: // PRIM_POINT_LIGHT: + shape = m_host.Shape; + + if (shape.LightEntry) + res.Add(new LSL_Types.LSLInteger(1)); // active + else + res.Add(new LSL_Types.LSLInteger(0)); + res.Add(new LSL_Types.Vector3(shape.LightColorR, // color + shape.LightColorG, + shape.LightColorB)); + res.Add(new LSL_Types.LSLFloat(shape.LightIntensity)); // intensity + res.Add(new LSL_Types.LSLFloat(shape.LightRadius)); // radius + res.Add(new LSL_Types.LSLFloat(shape.LightFalloff)); // falloff + break; + + case 24: // PRIM_GLOW + // TODO-------------- + if (remain < 1) + return res; + + face=Convert.ToInt32(rules.Data[idx++]); + + res.Add(new LSL_Types.LSLFloat(0)); + break; + } + } + return res; + } + + // + // + // The .NET definition of base 64 is: + // + // + // Significant: A-Z a-z 0-9 + - + // + // + // Whitespace: \t \n \r ' ' + // + // + // Valueless: = + // + // + // End-of-string: \0 or '==' + // + // + // + // + // Each point in a base-64 string represents + // a 6 bit value. A 32-bit integer can be + // represented using 6 characters (with some + // redundancy). + // + // + // LSL requires a base64 string to be 8 + // characters in length. LSL also uses '/' + // rather than '-' (MIME compliant). + // + // + // RFC 1341 used as a reference (as specified + // by the SecondLife Wiki). + // + // + // SL do not record any kind of exception for + // these functions, so the string to integer + // conversion returns '0' if an invalid + // character is encountered during conversion. + // + // + // References + // + // + // http://lslwiki.net/lslwiki/wakka.php?wakka=Base64 + // + // + // + // + // + // + + // + // Table for converting 6-bit integers into + // base-64 characters + // + + private static readonly char[] i2ctable = + { + 'A','B','C','D','E','F','G','H', + 'I','J','K','L','M','N','O','P', + 'Q','R','S','T','U','V','W','X', + 'Y','Z', + 'a','b','c','d','e','f','g','h', + 'i','j','k','l','m','n','o','p', + 'q','r','s','t','u','v','w','x', + 'y','z', + '0','1','2','3','4','5','6','7', + '8','9', + '+','/' + }; + + // + // Table for converting base-64 characters + // into 6-bit integers. + // + + private static readonly int[] c2itable = + { + -1,-1,-1,-1,-1,-1,-1,-1, // 0x + -1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1, // 1x + -1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1, // 2x + -1,-1,-1,63,-1,-1,-1,64, + 53,54,55,56,57,58,59,60, // 3x + 61,62,-1,-1,-1,0,-1,-1, + -1,1,2,3,4,5,6,7, // 4x + 8,9,10,11,12,13,14,15, + 16,17,18,19,20,21,22,23, // 5x + 24,25,26,-1,-1,-1,-1,-1, + -1,27,28,29,30,31,32,33, // 6x + 34,35,36,37,38,39,40,41, + 42,43,44,45,46,47,48,49, // 7x + 50,51,52,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1, // 8x + -1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1, // 9x + -1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1, // Ax + -1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1, // Bx + -1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1, // Cx + -1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1, // Dx + -1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1, // Ex + -1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1, // Fx + -1,-1,-1,-1,-1,-1,-1,-1 + }; + + // + // Converts a 32-bit integer into a Base64 + // character string. Base64 character strings + // are always 8 characters long. All iinteger + // values are acceptable. + // + // + // 32-bit integer to be converted. + // + // + // 8 character string. The 1st six characters + // contain the encoded number, the last two + // characters are padded with "=". + // + + public string llIntegerToBase64(int number) + { + // uninitialized string + + char[] imdt = new char[8]; + + m_host.AddScriptLPS(1); + + // Manually unroll the loop + + imdt[7] = '='; + imdt[6] = '='; + imdt[5] = i2ctable[number<<4 & 0x3F]; + imdt[4] = i2ctable[number>>2 & 0x3F]; + imdt[3] = i2ctable[number>>8 & 0x3F]; + imdt[2] = i2ctable[number>>14 & 0x3F]; + imdt[1] = i2ctable[number>>20 & 0x3F]; + imdt[0] = i2ctable[number>>26 & 0x3F]; + + return new string(imdt); + } + + // + // Converts an eight character base-64 string + // into a 32-bit integer. + // + // + // 8 characters string to be converted. Other + // length strings return zero. + // + // + // Returns an integer representing the + // encoded value providedint he 1st 6 + // characters of the string. + // + // + // This is coded to behave like LSL's + // implementation (I think), based upon the + // information available at the Wiki. + // If more than 8 characters are supplied, + // zero is returned. + // If a NULL string is supplied, zero will + // be returned. + // If fewer than 6 characters are supplied, then + // the answer will reflect a partial + // accumulation. + // + // The 6-bit segments are + // extracted left-to-right in big-endian mode, + // which means that segment 6 only contains the + // two low-order bits of the 32 bit integer as + // its high order 2 bits. A short string therefore + // means loss of low-order information. E.g. + // + // |<---------------------- 32-bit integer ----------------------->|<-Pad->| + // |<--Byte 0----->|<--Byte 1----->|<--Byte 2----->|<--Byte 3----->|<-Pad->| + // |3|3|2|2|2|2|2|2|2|2|2|2|1|1|1|1|1|1|1|1|1|1| | | | | | | | | | |P|P|P|P| + // |1|0|9|8|7|6|5|4|3|2|1|0|9|8|7|6|5|4|3|2|1|0|9|8|7|6|5|4|3|2|1|0|P|P|P|P| + // | str[0] | str[1] | str[2] | str[3] | str[4] | str[6] | + // + // + // + + public LSL_Types.LSLInteger llBase64ToInteger(string str) + { + int number = 0; + int digit; + + m_host.AddScriptLPS(1); + + // Require a well-fromed base64 string + + if (str.Length > 8) + return 0; + + // The loop is unrolled in the interests + // of performance and simple necessity. + // + // MUST find 6 digits to be well formed + // -1 == invalid + // 0 == padding + + if ((digit=c2itable[str[0]])<=0) + { + return digit<0?(int)0:number; + } + number += --digit<<26; + + if ((digit=c2itable[str[1]])<=0) + { + return digit<0?(int)0:number; + } + number += --digit<<20; + + if ((digit=c2itable[str[2]])<=0) + { + return digit<0?(int)0:number; + } + number += --digit<<14; + + if ((digit=c2itable[str[3]])<=0) + { + return digit<0?(int)0:number; + } + number += --digit<<8; + + if ((digit=c2itable[str[4]])<=0) + { + return digit<0?(int)0:number; + } + number += --digit<<2; + + if ((digit=c2itable[str[5]])<=0) + { + return digit<0?(int)0:number; + } + number += --digit>>4; + + // ignore trailing padding + + return number; + } + + public double llGetGMTclock() + { + m_host.AddScriptLPS(1); + return DateTime.UtcNow.TimeOfDay.TotalSeconds; + } + + public string llGetSimulatorHostname() + { + m_host.AddScriptLPS(1); + return System.Environment.MachineName; + } + + public void llSetLocalRot(LSL_Types.Quaternion rot) + { + m_host.AddScriptLPS(1); + m_host.RotationOffset = new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s); + } + + // + // Scan the string supplied in 'src' and + // tokenize it based upon two sets of + // tokenizers provided in two lists, + // separators and spacers. + // + // + // + // Separators demarcate tokens and are + // elided as they are encountered. Spacers + // also demarcate tokens, but are themselves + // retained as tokens. + // + // Both separators and spacers may be arbitrarily + // long strings. i.e. ":::". + // + // The function returns an ordered list + // representing the tokens found in the supplied + // sources string. If two successive tokenizers + // are encountered, then a NULL entry is added + // to the list. + // + // It is a precondition that the source and + // toekizer lisst are non-null. If they are null, + // then a null pointer exception will be thrown + // while their lengths are being determined. + // + // A small amount of working memoryis required + // of approximately 8*#tokenizers. + // + // There are many ways in which this function + // can be implemented, this implementation is + // fairly naive and assumes that when the + // function is invooked with a short source + // string and/or short lists of tokenizers, then + // performance will not be an issue. + // + // In order to minimize the perofrmance + // effects of long strings, or large numbers + // of tokeizers, the function skips as far as + // possible whenever a toekenizer is found, + // and eliminates redundant tokenizers as soon + // as is possible. + // + // The implementation tries to avoid any copying + // of arrays or other objects. + // + + public LSL_Types.list llParseStringKeepNulls(string src, LSL_Types.list separators, LSL_Types.list spacers) + { + int beginning = 0; + int srclen = src.Length; + int seplen = separators.Length; + object[] separray = separators.Data; + int spclen = spacers.Length; + object[] spcarray = spacers.Data; + int mlen = seplen+spclen; + + int[] offset = new int[mlen+1]; + bool[] active = new bool[mlen]; + + int best; + int j; + + // Initial capacity reduces resize cost + + LSL_Types.list tokens = new LSL_Types.list(); + + m_host.AddScriptLPS(1); + + // All entries are initially valid + + for (int i = 0; i < mlen; i++) + active[i] = true; + + offset[mlen] = srclen; + + while (beginning < srclen) + { + + best = mlen; // as bad as it gets + + // Scan for separators + + for (j = 0; j < seplen; j++) + { + if (active[j]) + { + // scan all of the markers + if ((offset[j] = src.IndexOf((string)separray[j],beginning)) == -1) + { + // not present at all + active[j] = false; + } + else + { + // present and correct + if (offset[j] < offset[best]) + { + // closest so far + best = j; + if (offset[best] == beginning) + break; + } + } + } + } + + // Scan for spacers + + if (offset[best] != beginning) + { + for (j = seplen; (j < mlen) && (offset[best] > beginning); j++) + { + if (active[j]) + { + // scan all of the markers + if ((offset[j] = src.IndexOf((string)spcarray[j-seplen], beginning)) == -1) + { + // not present at all + active[j] = false; + } + else + { + // present and correct + if (offset[j] < offset[best]) + { + // closest so far + best = j; + } + } + } + } + } + + // This is the normal exit from the scanning loop + + if (best == mlen) + { + // no markers were found on this pass + // so we're pretty much done + tokens.Add(src.Substring(beginning, srclen - beginning)); + break; + } + + // Otherwise we just add the newly delimited token + // and recalculate where the search should continue. + + tokens.Add(src.Substring(beginning,offset[best]-beginning)); + + if (best < seplen) + { + beginning = offset[best] + ((string)separray[best]).Length; + } + else + { + beginning = offset[best] + ((string)spcarray[best - seplen]).Length; + tokens.Add(spcarray[best - seplen]); + } + } + + // This an awkward an not very intuitive boundary case. If the + // last substring is a tokenizer, then there is an implied trailing + // null list entry. Hopefully the single comparison will not be too + // arduous. Alternatively the 'break' could be replced with a return + // but that's shabby programming. + + if (beginning == srclen) + { + if (srclen != 0) + tokens.Add(""); + } + + return tokens; + } + + public void llRezAtRoot(string inventory, LSL_Types.Vector3 position, LSL_Types.Vector3 velocity, + LSL_Types.Quaternion rot, int param) + { + m_host.AddScriptLPS(1); + NotImplemented("llRezAtRoot"); + } + + public LSL_Types.LSLInteger llGetObjectPermMask(int mask) + { + m_host.AddScriptLPS(1); + + int permmask = 0; + + if (mask == ScriptBaseClass.MASK_BASE)//0 + { + permmask = (int)m_host.BaseMask; + } + + else if (mask == ScriptBaseClass.MASK_OWNER)//1 + { + permmask = (int)m_host.OwnerMask; + } + + else if (mask == ScriptBaseClass.MASK_GROUP)//2 + { + permmask = (int)m_host.GroupMask; + } + + else if (mask == ScriptBaseClass.MASK_EVERYONE)//3 + { + permmask = (int)m_host.EveryoneMask; + } + + else if (mask == ScriptBaseClass.MASK_NEXT)//4 + { + permmask = (int)m_host.NextOwnerMask; + } + + return permmask; + } + + public void llSetObjectPermMask(int mask, int value) + { + m_host.AddScriptLPS(1); + IConfigSource config = new IniConfigSource(Application.iniFilePath); + if (config.Configs["XEngine"] == null) + config.AddConfig("XEngine"); + + if (config.Configs["XEngine"].GetBoolean("AllowGodFunctions", false)) + { + if (World.ExternalChecks.ExternalChecksCanRunConsoleCommand(m_host.OwnerID)) + { + if (mask == ScriptBaseClass.MASK_BASE)//0 + { + m_host.BaseMask = (uint)value; + } + + else if (mask == ScriptBaseClass.MASK_OWNER)//1 + { + m_host.OwnerMask = (uint)value; + } + + else if (mask == ScriptBaseClass.MASK_GROUP)//2 + { + m_host.GroupMask = (uint)value; + } + + else if (mask == ScriptBaseClass.MASK_EVERYONE)//3 + { + m_host.EveryoneMask = (uint)value; + } + + else if (mask == ScriptBaseClass.MASK_NEXT)//4 + { + m_host.NextOwnerMask = (uint)value; + } + } + } + } + + public LSL_Types.LSLInteger llGetInventoryPermMask(string item, int mask) + { + m_host.AddScriptLPS(1); + foreach (KeyValuePair inv in m_host.TaskInventory) + { + if (inv.Value.Name == item) + { + switch (mask) + { + case 0: + return (int)inv.Value.BaseMask; + case 1: + return (int)inv.Value.OwnerMask; + case 2: + return (int)inv.Value.GroupMask; + case 3: + return (int)inv.Value.EveryoneMask; + case 4: + return (int)inv.Value.NextOwnerMask; + } + } + } + return -1; + } + + public void llSetInventoryPermMask(string item, int mask, int value) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetInventoryPermMask"); + } + + public string llGetInventoryCreator(string item) + { + m_host.AddScriptLPS(1); + foreach (KeyValuePair inv in m_host.TaskInventory) + { + if (inv.Value.Name == item) + { + return inv.Value.CreatorID.ToString(); + } + } + llSay(0, "No item name '" + item + "'"); + return String.Empty; + } + + public void llOwnerSay(string msg) + { + m_host.AddScriptLPS(1); + + World.SimChatBroadcast(Helpers.StringToField(msg), ChatTypeEnum.Owner, 0, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false); +// IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); +// wComm.DeliverMessage(ChatTypeEnum.Owner, 0, m_host.Name, m_host.UUID, msg); + } + + public string llRequestSimulatorData(string simulator, int data) + { + try + { + m_host.AddScriptLPS(1); + + string reply = String.Empty; + + RegionInfo info = m_ScriptEngine.World.RequestClosestRegion(simulator); + + switch (data) + { + case 5: // DATA_SIM_POS + if (info == null) + return LLUUID.Zero.ToString(); + reply = new LSL_Types.Vector3( + info.RegionLocX * Constants.RegionSize, + info.RegionLocY * Constants.RegionSize, + 0).ToString(); + break; + case 6: // DATA_SIM_STATUS + if (info != null) + reply = "up"; // Duh! + else + reply = "unknown"; + break; + case 7: // DATA_SIM_RATING + if (info == null) + return LLUUID.Zero.ToString(); + int access = (int)info.EstateSettings.simAccess; + if (access == 21) + reply = "MATURE"; + else if (access == 13) + reply = "MATURE"; + else + reply = "UNKNOWN"; + break; + default: + return LLUUID.Zero.ToString(); // Raise no event + } + LLUUID rq = LLUUID.Random(); + + LLUUID tid = AsyncCommands. + DataserverPlugin.RegisterRequest(m_localID, + m_itemID, rq.ToString()); + + AsyncCommands. + DataserverPlugin.DataserverReply(rq.ToString(), reply); + + return tid.ToString(); + } + catch(Exception e) + { + Console.WriteLine(e.ToString()); + return LLUUID.Zero.ToString(); + } + } + + public void llForceMouselook(int mouselook) + { + m_host.AddScriptLPS(1); + NotImplemented("llForceMouselook"); + } + + public double llGetObjectMass(string id) + { + m_host.AddScriptLPS(1); + LLUUID key = new LLUUID(); + if (LLUUID.TryParse(id,out key)) + { + return (double) World.GetSceneObjectPart(World.Entities[key].LocalId).GetMass(); + } + return 0; + } + + /// + /// illListReplaceList removes the sub-list defined by the inclusive indices + /// start and end and inserts the src list in its place. The inclusive + /// nature of the indices means that at least one element must be deleted + /// if the indices are within the bounds of the existing list. I.e. 2,2 + /// will remove the element at index 2 and replace it with the source + /// list. Both indices may be negative, with the usual interpretation. An + /// interesting case is where end is lower than start. As these indices + /// bound the list to be removed, then 0->end, and start->lim are removed + /// and the source list is added as a suffix. + /// + + public LSL_Types.list llListReplaceList(LSL_Types.list dest, LSL_Types.list src, int start, int end) + { + LSL_Types.list pref = null; + + m_host.AddScriptLPS(1); + + // Note that although we have normalized, both + // indices could still be negative. + if (start < 0) + { + start = start+dest.Length; + } + + if (end < 0) + { + end = end+dest.Length; + } + // The comventional case, remove a sequence starting with + // start and ending with end. And then insert the source + // list. + if (start <= end) + { + // If greater than zero, then there is going to be a + // surviving prefix. Otherwise the inclusive nature + // of the indices mean that we're going to add the + // source list as a prefix. + if (start > 0) + { + pref = dest.GetSublist(0,start-1); + // Only add a suffix if there is something + // beyond the end index (it's inclusive too). + if (end + 1 < dest.Length) + { + return pref + src + dest.GetSublist(end + 1, -1); + } + else + { + return pref + src; + } + } + // If start is less than or equal to zero, then + // the new list is simply a prefix. We still need to + // figure out any necessary surgery to the destination + // based upon end. Note that if end exceeds the upper + // bound in this case, the entire destination list + // is removed. + else + { + if (end + 1 < dest.Length) + { + return src + dest.GetSublist(end + 1, -1); + } + else + { + return src; + } + } + } + // Finally, if start > end, we strip away a prefix and + // a suffix, to leave the list that sits ens + // and start, and then tag on the src list. AT least + // that's my interpretation. We can get sublist to do + // this for us. Note that one, or both of the indices + // might have been negative. + else + { + return dest.GetSublist(end + 1, start - 1) + src; + } + } + + public void llLoadURL(string avatar_id, string message, string url) + { + m_host.AddScriptLPS(1); + LLUUID avatarId = new LLUUID(avatar_id); + m_ScriptEngine.World.SendUrlToUser(avatarId, m_host.Name, m_host.UUID, m_host.ObjectOwner, false, message, + url); + } + + public void llParcelMediaCommandList(LSL_Types.list commandList) + { + m_host.AddScriptLPS(1); + NotImplemented("llParcelMediaCommandList"); + } + + public void llParcelMediaQuery() + { + m_host.AddScriptLPS(1); + NotImplemented("llParcelMediaQuery"); + } + + public LSL_Types.LSLInteger llModPow(int a, int b, int c) + { + m_host.AddScriptLPS(1); + Int64 tmp = 0; + Math.DivRem(Convert.ToInt64(Math.Pow(a, b)), c, out tmp); + return Convert.ToInt32(tmp); + } + + public LSL_Types.LSLInteger llGetInventoryType(string name) + { + m_host.AddScriptLPS(1); + foreach (KeyValuePair inv in m_host.TaskInventory) + { + if (inv.Value.Name == name) + { + return inv.Value.InvType; + } + } + return -1; + } + + public void llSetPayPrice(int price, LSL_Types.list quick_pay_buttons) + { + m_host.AddScriptLPS(1); + + if (quick_pay_buttons.Data.Length != 4) + { + LSLError("List must have 4 elements"); + return; + } + m_host.ParentGroup.RootPart.PayPrice[0]=price; + m_host.ParentGroup.RootPart.PayPrice[1]=(int)quick_pay_buttons.Data[0]; + m_host.ParentGroup.RootPart.PayPrice[2]=(int)quick_pay_buttons.Data[1]; + m_host.ParentGroup.RootPart.PayPrice[3]=(int)quick_pay_buttons.Data[2]; + m_host.ParentGroup.RootPart.PayPrice[4]=(int)quick_pay_buttons.Data[3]; + } + + public LSL_Types.Vector3 llGetCameraPos() + { + m_host.AddScriptLPS(1); + NotImplemented("llGetCameraPos"); + return new LSL_Types.Vector3(); + } + + public LSL_Types.Quaternion llGetCameraRot() + { + m_host.AddScriptLPS(1); + NotImplemented("llGetCameraRot"); + return new LSL_Types.Quaternion(); + } + + public void llSetPrimURL() + { + m_host.AddScriptLPS(1); + NotImplemented("llSetPrimURL"); + } + + public void llRefreshPrimURL() + { + m_host.AddScriptLPS(1); + NotImplemented("llRefreshPrimURL"); + } + + public string llEscapeURL(string url) + { + m_host.AddScriptLPS(1); + try + { + return Uri.EscapeUriString(url); + } + catch (Exception ex) + { + return "llEscapeURL: " + ex.ToString(); + } + } + + public string llUnescapeURL(string url) + { + m_host.AddScriptLPS(1); + try + { + return Uri.UnescapeDataString(url); + } + catch (Exception ex) + { + return "llUnescapeURL: " + ex.ToString(); + } + } + + public void llMapDestination(string simname, LSL_Types.Vector3 pos, LSL_Types.Vector3 look_at) + { + m_host.AddScriptLPS(1); + NotImplemented("llMapDestination"); + } + + public void llAddToLandBanList(string avatar, double hours) + { + m_host.AddScriptLPS(1); + LLUUID key; + LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData; + if (land.ownerID == m_host.OwnerID) + { + ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry(); + if (LLUUID.TryParse(avatar, out key)) + { + entry.AgentID = key; + entry.Flags = ParcelManager.AccessList.Ban; + entry.Time = DateTime.Now.AddHours(hours); + land.parcelAccessList.Add(entry); + } + } + } + + public void llRemoveFromLandPassList(string avatar) + { + m_host.AddScriptLPS(1); + LLUUID key; + LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData; + if (land.ownerID == m_host.OwnerID) + { + if (LLUUID.TryParse(avatar, out key)) + { + foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList) + { + if (entry.AgentID == key && entry.Flags == ParcelManager.AccessList.Access) + { + land.parcelAccessList.Remove(entry); + break; + } + } + } + } + } + + public void llRemoveFromLandBanList(string avatar) + { + m_host.AddScriptLPS(1); + LLUUID key; + LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData; + if (land.ownerID == m_host.OwnerID) + { + if (LLUUID.TryParse(avatar, out key)) + { + foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList) + { + if (entry.AgentID == key && entry.Flags == ParcelManager.AccessList.Ban) + { + land.parcelAccessList.Remove(entry); + break; + } + } + } + } + } + + public void llSetCameraParams(LSL_Types.list rules) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetCameraParams"); + } + + public void llClearCameraParams() + { + m_host.AddScriptLPS(1); + NotImplemented("llClearCameraParams"); + } + + public double llListStatistics(int operation, LSL_Types.list src) + { + m_host.AddScriptLPS(1); + LSL_Types.list nums = LSL_Types.list.ToDoubleList(src); + switch (operation) + { + case ScriptBaseClass.LIST_STAT_RANGE: + return nums.Range(); + case ScriptBaseClass.LIST_STAT_MIN: + return nums.Min(); + case ScriptBaseClass.LIST_STAT_MAX: + return nums.Max(); + case ScriptBaseClass.LIST_STAT_MEAN: + return nums.Mean(); + case ScriptBaseClass.LIST_STAT_MEDIAN: + return nums.Median(); + case ScriptBaseClass.LIST_STAT_NUM_COUNT: + return nums.NumericLength(); + case ScriptBaseClass.LIST_STAT_STD_DEV: + return nums.StdDev(); + case ScriptBaseClass.LIST_STAT_SUM: + return nums.Sum(); + case ScriptBaseClass.LIST_STAT_SUM_SQUARES: + return nums.SumSqrs(); + case ScriptBaseClass.LIST_STAT_GEOMETRIC_MEAN: + return nums.GeometricMean(); + case ScriptBaseClass.LIST_STAT_HARMONIC_MEAN: + return nums.HarmonicMean(); + default: + return 0.0; + } + } + + public LSL_Types.LSLInteger llGetUnixTime() + { + m_host.AddScriptLPS(1); + return Util.UnixTimeSinceEpoch(); + } + + public LSL_Types.LSLInteger llGetParcelFlags(LSL_Types.Vector3 pos) + { + m_host.AddScriptLPS(1); + return (int)World.LandChannel.GetLandObject((float)pos.x, (float)pos.y).landData.landFlags; + } + + public LSL_Types.LSLInteger llGetRegionFlags() + { + m_host.AddScriptLPS(1); + return (int)World.RegionInfo.EstateSettings.regionFlags; + } + + public string llXorBase64StringsCorrect(string str1, string str2) + { + m_host.AddScriptLPS(1); + string ret = String.Empty; + string src1 = llBase64ToString(str1); + string src2 = llBase64ToString(str2); + int c = 0; + for (int i = 0; i < src1.Length; i++) + { + ret += src1[i] ^ src2[c]; + + c++; + if (c > src2.Length) + c = 0; + } + return llStringToBase64(ret); + } + + public string llHTTPRequest(string url, LSL_Types.list parameters, string body) + { + // Partial implementation: support for parameter flags needed + // see http://wiki.secondlife.com/wiki/LlHTTPRequest + // parameter flags support are implemented in ScriptsHttpRequests.cs + // in StartHttpRequest + + m_host.AddScriptLPS(1); + IHttpRequests httpScriptMod = + m_ScriptEngine.World.RequestModuleInterface(); + List param = new List(); + foreach (object o in parameters.Data) + { + param.Add(o.ToString()); + } + LLUUID reqID = httpScriptMod. + StartHttpRequest(m_localID, m_itemID, url, param, body); + + if (reqID != LLUUID.Zero) + return reqID.ToString(); + else + return null; + } + + public void llResetLandBanList() + { + m_host.AddScriptLPS(1); + LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData; + if (land.ownerID == m_host.OwnerID) + { + foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList) + { + if (entry.Flags == ParcelManager.AccessList.Ban) + { + land.parcelAccessList.Remove(entry); + } + } + } + } + + public void llResetLandPassList() + { + m_host.AddScriptLPS(1); + LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData; + if (land.ownerID == m_host.OwnerID) + { + foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList) + { + if (entry.Flags == ParcelManager.AccessList.Access) + { + land.parcelAccessList.Remove(entry); + } + } + } + } + + public LSL_Types.LSLInteger llGetParcelPrimCount(LSL_Types.Vector3 pos, int category, int sim_wide) + { + m_host.AddScriptLPS(1); + + LandData land = World.GetLandData((float)pos.x, (float)pos.y); + + if (land == null) + { + return 0; + } + + else + { + if (sim_wide == 1) + { + if (category == 0) + { + return land.simwidePrims; + } + + else + { + //public int simwideArea = 0; + return 0; + } + } + + else + { + if (category == 0)//Total Prims + { + return 0;//land. + } + + else if (category == 1)//Owner Prims + { + return land.ownerPrims; + } + + else if (category == 2)//Group Prims + { + return land.groupPrims; + } + + else if (category == 3)//Other Prims + { + return land.otherPrims; + } + + else if (category == 4)//Selected + { + return land.selectedPrims; + } + + else if (category == 5)//Temp + { + return 0;//land. + } + } + } + return 0; + } + + public LSL_Types.list llGetParcelPrimOwners(LSL_Types.Vector3 pos) + { + m_host.AddScriptLPS(1); + LandObject land = (LandObject)World.LandChannel.GetLandObject((float)pos.x, (float)pos.y); + LSL_Types.list ret = new LSL_Types.list(); + if (land != null) + { + foreach (KeyValuePair d in land.getLandObjectOwners()) + { + ret.Add(d.Key.ToString()); + ret.Add(d.Value); + } + } + return ret; + } + + public LSL_Types.LSLInteger llGetObjectPrimCount(string object_id) + { + m_host.AddScriptLPS(1); + SceneObjectPart part = World.GetSceneObjectPart(new LLUUID(object_id)); + if (part == null) + { + return 0; + } + else + { + return part.ParentGroup.Children.Count; + } + } + + public LSL_Types.LSLInteger llGetParcelMaxPrims(LSL_Types.Vector3 pos, int sim_wide) + { + m_host.AddScriptLPS(1); + // Alondria: This currently just is utilizing the normal grid's 0.22 prims/m2 calculation + // Which probably will be irrelevent in OpenSim.... + LandData land = World.GetLandData((float)pos.x, (float)pos.y); + + float bonusfactor = World.RegionInfo.EstateSettings.objectBonusFactor; + + if (land == null) + { + return 0; + } + + if (sim_wide == 1) + { + decimal v = land.simwideArea * (decimal)(0.22) * (decimal)bonusfactor; + + return (int)v; + } + + else + { + decimal v = land.area * (decimal)(0.22) * (decimal)bonusfactor; + + return (int)v; + } + + } + + public LSL_Types.list llGetParcelDetails(LSL_Types.Vector3 pos, LSL_Types.list param) + { + m_host.AddScriptLPS(1); + LandData land = World.GetLandData((float)pos.x, (float)pos.y); + if (land == null) + { + return new LSL_Types.list(0); + } + LSL_Types.list ret = new LSL_Types.list(); + foreach (object o in param.Data) + { + switch (o.ToString()) + { + case "0": + ret = ret + new LSL_Types.list(land.landName); + break; + case "1": + ret = ret + new LSL_Types.list(land.landDesc); + break; + case "2": + ret = ret + new LSL_Types.list(land.ownerID.ToString()); + break; + case "3": + ret = ret + new LSL_Types.list(land.groupID.ToString()); + break; + case "4": + ret = ret + new LSL_Types.list(land.area); + break; + default: + ret = ret + new LSL_Types.list(0); + break; + } + } + return ret; + } + + public void llSetLinkTexture(int linknumber, string texture, int face) + { + m_host.AddScriptLPS(1); + NotImplemented("llSetLinkTexture"); + } + + public string llStringTrim(string src, int type) + { + m_host.AddScriptLPS(1); + if (type == (int)ScriptBaseClass.STRING_TRIM_HEAD) { return src.TrimStart(); } + if (type == (int)ScriptBaseClass.STRING_TRIM_TAIL) { return src.TrimEnd(); } + if (type == (int)ScriptBaseClass.STRING_TRIM) { return src.Trim(); } + return src; + } + + public LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args) + { + m_host.AddScriptLPS(1); + LSL_Types.list ret = new LSL_Types.list(); + LLUUID key = new LLUUID(); + if (LLUUID.TryParse(id, out key)) + { + ScenePresence av = World.GetScenePresence(key); + + if (av != null) + { + foreach (object o in args.Data) + { + switch (o.ToString()) + { + case "1": + ret.Add(av.Firstname + " " + av.Lastname); + break; + case "2": + ret.Add(""); + break; + case "3": + ret.Add(new LSL_Types.Vector3((double)av.AbsolutePosition.X, (double)av.AbsolutePosition.Y, (double)av.AbsolutePosition.Z)); + break; + case "4": + ret.Add(new LSL_Types.Quaternion((double)av.Rotation.x, (double)av.Rotation.y, (double)av.Rotation.z, (double)av.Rotation.w)); + break; + case "5": + ret.Add(new LSL_Types.Vector3(av.Velocity.X,av.Velocity.Y,av.Velocity.Z)); + break; + case "6": + ret.Add(id); + break; + case "7": + ret.Add(LLUUID.Zero.ToString()); + break; + case "8": + ret.Add(LLUUID.Zero.ToString()); + break; + } + } + return ret; + } + SceneObjectPart obj = World.GetSceneObjectPart(key); + if (obj != null) + { + foreach (object o in args.Data) + { + switch (o.ToString()) + { + case "1": + ret.Add(obj.Name); + break; + case "2": + ret.Add(obj.Description); + break; + case "3": + ret.Add(new LSL_Types.Vector3(obj.AbsolutePosition.X,obj.AbsolutePosition.Y,obj.AbsolutePosition.Z)); + break; + case "4": + ret.Add(new LSL_Types.Quaternion(obj.RotationOffset.X, obj.RotationOffset.Y, obj.RotationOffset.Z, obj.RotationOffset.W)); + break; + case "5": + ret.Add(new LSL_Types.Vector3(obj.Velocity.X, obj.Velocity.Y, obj.Velocity.Z)); + break; + case "6": + ret.Add(obj.OwnerID.ToString()); + break; + case "7": + ret.Add(obj.GroupID.ToString()); + break; + case "8": + ret.Add(obj.CreatorID.ToString()); + break; + } + } + return ret; + } + } + return new LSL_Types.list(); + } + + + internal LLUUID ScriptByName(string name) + { + foreach (TaskInventoryItem item in m_host.TaskInventory.Values) + { + if (item.Type == 10 && item.Name == name) + return item.ItemID; + } + return LLUUID.Zero; + } + + internal void ShoutError(string msg) + { + llShout(ScriptBaseClass.DEBUG_CHANNEL, msg); + } + + + + internal void NotImplemented(string command) + { + if (throwErrorOnNotImplemented) + throw new NotImplementedException("Command not implemented: " + command); + } + + internal void Deprecated(string command) + { + throw new Exception("Command deprecated: " + command); + } + + internal void LSLError(string msg) + { + throw new Exception("LSL Runtime Error: " + msg); + } + + public delegate void AssetRequestCallback(LLUUID assetID, AssetBase asset); + private void WithNotecard(LLUUID assetID, AssetRequestCallback cb) + { + World.AssetCache.GetAsset(assetID, delegate(LLUUID i, AssetBase a) { cb(i, a); }, false); + } + + public string llGetNumberOfNotecardLines(string name) + { + m_host.AddScriptLPS(1); + + foreach (TaskInventoryItem item in m_host.TaskInventory.Values) + { + if (item.Type == 7 && item.Name == name) + { + LLUUID tid = AsyncCommands. + DataserverPlugin.RegisterRequest(m_localID, + m_itemID, item.AssetID.ToString()); + if (NotecardCache.IsCached(item.AssetID)) + { + AsyncCommands. + DataserverPlugin.DataserverReply(item.AssetID.ToString(), + NotecardCache.GetLines(item.AssetID).ToString()); + return tid.ToString(); + } + WithNotecard(item.AssetID, delegate (LLUUID id, AssetBase a) + { + System.Text.ASCIIEncoding enc = + new System.Text.ASCIIEncoding(); + string data = enc.GetString(a.Data); + //Console.WriteLine(data); + NotecardCache.Cache(id, data); + AsyncCommands. + DataserverPlugin.DataserverReply(id.ToString(), + NotecardCache.GetLines(id).ToString()); + }); + + return tid.ToString(); + } + } + return LLUUID.Zero.ToString(); + } + + public string llGetNotecardLine(string name, int line) + { + m_host.AddScriptLPS(1); + + foreach (TaskInventoryItem item in m_host.TaskInventory.Values) + { + if (item.Type == 7 && item.Name == name) + { + LLUUID tid = AsyncCommands. + DataserverPlugin.RegisterRequest(m_localID, + m_itemID, item.AssetID.ToString()); + if (NotecardCache.IsCached(item.AssetID)) + { + AsyncCommands. + DataserverPlugin.DataserverReply(item.AssetID.ToString(), + NotecardCache.GetLine(item.AssetID, line)); + return tid.ToString(); + } + WithNotecard(item.AssetID, delegate (LLUUID id, AssetBase a) + { + System.Text.ASCIIEncoding enc = + new System.Text.ASCIIEncoding(); + string data = enc.GetString(a.Data); + //Console.WriteLine(data); + NotecardCache.Cache(id, data); + AsyncCommands. + DataserverPlugin.DataserverReply(id.ToString(), + NotecardCache.GetLine(id, line)); + }); + + return tid.ToString(); + } + } + + return String.Empty; + } + + } + + public class NotecardCache + { + private class Notecard + { + public string[] text; + public DateTime lastRef; + } + + private static Dictionary m_Notecards = + new Dictionary(); + + public static void Cache(LLUUID assetID, string text) + { + CacheCheck(); + + lock (m_Notecards) + { + if (m_Notecards.ContainsKey(assetID)) + return; + + Notecard nc = new Notecard(); + nc.lastRef = DateTime.Now; + nc.text = ParseText(text.Replace("\r", "").Split('\n')); + m_Notecards[assetID] = nc; + } + } + + private static string[] ParseText(string[] input) + { + int idx = 0; + int level = 0; + List output = new List(); + string[] words; + + while (idx < input.Length) + { + if (input[idx] == "{") + { + level++; + idx++; + continue; + } + + if (input[idx]== "}") + { + level--; + idx++; + continue; + } + + switch (level) + { + case 0: + words = input[idx].Split(' '); // Linden text ver + int version = int.Parse(words[3]); + if (version != 2) + return new String[0]; + break; + case 1: + words = input[idx].Split(' '); + if (words[0] == "LLEmbeddedItems") + break; + if (words[0] == "Text") + { + int len = int.Parse(words[2]); + idx++; + + int count = -1; + + while (count < len) + { + int l = input[idx].Length; + string ln = input[idx]; + + int need = len-count-1; + if (ln.Length > need) + ln = ln.Substring(0, need); + + output.Add(ln); + count += ln.Length + 1; + idx++; + } + + return output.ToArray(); + } + break; + case 2: + words = input[idx].Split(' '); // count + if (words[0] == "count") + { + int c = int.Parse(words[1]); + if (c > 0) + return new String[0]; + break; + } + break; + } + idx++; + } + return output.ToArray(); + } + + public static bool IsCached(LLUUID assetID) + { + lock (m_Notecards) + { + return m_Notecards.ContainsKey(assetID); + } + } + + public static int GetLines(LLUUID assetID) + { + if (!IsCached(assetID)) + return -1; + + lock (m_Notecards) + { + m_Notecards[assetID].lastRef = DateTime.Now; + return m_Notecards[assetID].text.Length; + } + } + + public static string GetLine(LLUUID assetID, int line) + { + if (line < 0) + return ""; + + string data; + + if (!IsCached(assetID)) + return ""; + + lock (m_Notecards) + { + m_Notecards[assetID].lastRef = DateTime.Now; + + if (line >= m_Notecards[assetID].text.Length) + return "\n\n\n"; + + data = m_Notecards[assetID].text[line]; + if (data.Length > 255) + data = data.Substring(0, 255); + + return data; + } + } + + public static void CacheCheck() + { + foreach (LLUUID key in new List(m_Notecards.Keys)) + { + Notecard nc = m_Notecards[key]; + if (nc.lastRef.AddSeconds(30) < DateTime.Now) + m_Notecards.Remove(key); + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs new file mode 100644 index 0000000..dbb78a4 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs @@ -0,0 +1,553 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +using System; +using Axiom.Math; +using libsecondlife; +using Nini.Config; +using OpenSim.Framework.Console; +using OpenSim.Region.Environment.Interfaces; +using OpenSim.Region.Environment.Scenes; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.ScriptEngine.Shared.Api.Plugins; +using OpenSim.Region.ScriptEngine.Shared.ScriptBase; +using OpenSim.Region.ScriptEngine.Interfaces; +using OpenSim.Region.ScriptEngine.Shared.Api.Interfaces; + +namespace OpenSim.Region.ScriptEngine.Shared.Api +{ + [Serializable] + public class OSSL_Api : MarshalByRefObject, IOSSL_Api, IScriptApi + { + internal IScriptEngine m_ScriptEngine; + internal SceneObjectPart m_host; + internal uint m_localID; + internal LLUUID m_itemID; + + public void Initialize(IScriptEngine ScriptEngine, SceneObjectPart host, uint localID, LLUUID itemID) + { + m_ScriptEngine = ScriptEngine; + m_host = host; + m_localID = localID; + m_itemID = itemID; + } + + + // + // OpenSim functions + // + + public int osTerrainSetHeight(int x, int y, double val) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osTerrainSetHeight: permission denied"); + return 0; + } + + m_host.AddScriptLPS(1); + if (x > 255 || x < 0 || y > 255 || y < 0) + OSSLError("osTerrainSetHeight: Coordinate out of bounds"); + + if (World.ExternalChecks.ExternalChecksCanTerraformLand(m_host.OwnerID, new LLVector3(x, y, 0))) + { + World.Heightmap[x, y] = val; + return 1; + } + else + { + return 0; + } + } + + public double osTerrainGetHeight(int x, int y) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osTerrainGetHeight: permission denied"); + return 0.0; + } + + m_host.AddScriptLPS(1); + if (x > 255 || x < 0 || y > 255 || y < 0) + OSSLError("osTerrainGetHeight: Coordinate out of bounds"); + + return World.Heightmap[x, y]; + } + + public int osRegionRestart(double seconds) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osRegionRestart: permission denied"); + return 0; + } + + m_host.AddScriptLPS(1); + if (World.ExternalChecks.ExternalChecksCanIssueEstateCommand(m_host.OwnerID)) + { + World.Restart((float)seconds); + return 1; + } + else + { + return 0; + } + } + + public void osRegionNotice(string msg) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osRegionNotice: permission denied"); + return; + } + + m_host.AddScriptLPS(1); + World.SendGeneralAlert(msg); + } + + public void osSetRot(LLUUID target, Quaternion rotation) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osSetRot: permission denied"); + return; + } + + m_host.AddScriptLPS(1); + if (World.Entities.ContainsKey(target)) + { + World.Entities[target].Rotation = rotation; + } + else + { + OSSLError("osSetRot: Invalid target"); + } + } + + public string osSetDynamicTextureURL(string dynamicID, string contentType, string url, string extraParams, + int timer) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osSetDynamicTextureURL: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + if (dynamicID == String.Empty) + { + IDynamicTextureManager textureManager = World.RequestModuleInterface(); + LLUUID createdTexture = + textureManager.AddDynamicTextureURL(World.RegionInfo.RegionID, m_host.UUID, contentType, url, + extraParams, timer); + return createdTexture.ToString(); + } + else + { + //TODO update existing dynamic textures + } + + return LLUUID.Zero.ToString(); + } + + public string osSetDynamicTextureURLBlend(string dynamicID, string contentType, string url, string extraParams, + int timer, int alpha) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osSetDynamicTextureURLBlend: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + if (dynamicID == String.Empty) + { + IDynamicTextureManager textureManager = World.RequestModuleInterface(); + LLUUID createdTexture = + textureManager.AddDynamicTextureURL(World.RegionInfo.RegionID, m_host.UUID, contentType, url, + extraParams, timer, true, (byte) alpha); + return createdTexture.ToString(); + } + else + { + //TODO update existing dynamic textures + } + + return LLUUID.Zero.ToString(); + } + + public string osSetDynamicTextureData(string dynamicID, string contentType, string data, string extraParams, + int timer) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osSetDynamicTextureData: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + if (dynamicID == String.Empty) + { + IDynamicTextureManager textureManager = World.RequestModuleInterface(); + if (textureManager != null) + { + LLUUID createdTexture = + textureManager.AddDynamicTextureData(World.RegionInfo.RegionID, m_host.UUID, contentType, data, + extraParams, timer); + return createdTexture.ToString(); + } + } + else + { + //TODO update existing dynamic textures + } + + return LLUUID.Zero.ToString(); + } + + public string osSetDynamicTextureDataBlend(string dynamicID, string contentType, string data, string extraParams, + int timer, int alpha) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osSetDynamicTextureDataBlend: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + if (dynamicID == String.Empty) + { + IDynamicTextureManager textureManager = World.RequestModuleInterface(); + if (textureManager != null) + { + LLUUID createdTexture = + textureManager.AddDynamicTextureData(World.RegionInfo.RegionID, m_host.UUID, contentType, data, + extraParams, timer, true, (byte) alpha); + return createdTexture.ToString(); + } + } + else + { + //TODO update existing dynamic textures + } + + return LLUUID.Zero.ToString(); + } + + public bool osConsoleCommand(string command) + { + m_host.AddScriptLPS(1); + if (m_ScriptEngine.Config.GetBoolean("AllowosConsoleCommand", false)) + { + if (World.ExternalChecks.ExternalChecksCanRunConsoleCommand(m_host.OwnerID)) + { + MainConsole.Instance.RunCommand(command); + return true; + } + return false; + } + return false; + } + public void osSetPrimFloatOnWater(int floatYN) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osSetPrimFloatOnWater: permission denied"); + return; + } + + m_host.AddScriptLPS(1); + if (m_host.ParentGroup != null) + { + if (m_host.ParentGroup.RootPart != null) + { + m_host.ParentGroup.RootPart.SetFloatOnWater(floatYN); + } + } + } + + // Adam's super super custom animation functions + public void osAvatarPlayAnimation(string avatar, string animation) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osAvatarPlayAnimation: permission denied"); + return; + } + + m_host.AddScriptLPS(1); + if (World.Entities.ContainsKey(avatar) && World.Entities[avatar] is ScenePresence) + { + ScenePresence target = (ScenePresence)World.Entities[avatar]; + target.AddAnimation(avatar); + } + } + + public void osAvatarStopAnimation(string avatar, string animation) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osAvatarStopAnimation: permission denied"); + return; + } + + m_host.AddScriptLPS(1); + if (World.Entities.ContainsKey(avatar) && World.Entities[avatar] is ScenePresence) + { + ScenePresence target = (ScenePresence)World.Entities[avatar]; + target.RemoveAnimation(animation); + } + } + + //Texture draw functions + public string osMovePen(string drawList, int x, int y) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osMovePen: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + drawList += "MoveTo " + x + "," + y + ";"; + return drawList; + } + + public string osDrawLine(string drawList, int startX, int startY, int endX, int endY) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osDrawLine: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + drawList += "MoveTo "+ startX+","+ startY +"; LineTo "+endX +","+endY +"; "; + return drawList; + } + + public string osDrawLine(string drawList, int endX, int endY) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osDrawLine: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + drawList += "LineTo " + endX + "," + endY + "; "; + return drawList; + } + + public string osDrawText(string drawList, string text) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osDrawText: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + drawList += "Text " + text + "; "; + return drawList; + } + + public string osDrawEllipse(string drawList, int width, int height) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osDrawEllipse: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + drawList += "Ellipse " + width + "," + height + "; "; + return drawList; + } + + public string osDrawRectangle(string drawList, int width, int height) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osDrawRectangle: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + drawList += "Rectangle " + width + "," + height + "; "; + return drawList; + } + + public string osDrawFilledRectangle(string drawList, int width, int height) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osDrawFilledRectangle: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + drawList += "FillRectangle " + width + "," + height + "; "; + return drawList; + } + + public string osSetFontSize(string drawList, int fontSize) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osSetFontSize: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + drawList += "FontSize "+ fontSize +"; "; + return drawList; + } + + public string osSetPenSize(string drawList, int penSize) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osSetPenSize: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + drawList += "PenSize " + penSize + "; "; + return drawList; + } + + public string osSetPenColour(string drawList, string colour) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osSetPenColour: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + drawList += "PenColour " + colour + "; "; + return drawList; + } + + public string osDrawImage(string drawList, int width, int height, string imageUrl) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osDrawImage: permission denied"); + return String.Empty; + } + + m_host.AddScriptLPS(1); + drawList +="Image " +width + "," + height+ ","+ imageUrl +"; " ; + return drawList; + } + + public void osSetStateEvents(int events) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osSetStateEvents: permission denied"); + return; + } + + m_host.SetScriptEvents(m_itemID, events); + } + + public void osSetRegionWaterHeight(double height) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osSetRegionWaterHeight: permission denied"); + return; + } + + m_host.AddScriptLPS(1); + //Check to make sure that the script's owner is the estate manager/master + //World.Permissions.GenericEstatePermission( + if (World.ExternalChecks.ExternalChecksCanBeGodLike(m_host.OwnerID)) + { + World.EventManager.TriggerRequestChangeWaterHeight((float)height); + } + } + + public double osList2Double(LSL_Types.list src, int index) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osList2Double: permission denied"); + return 0.0; + } + + m_host.AddScriptLPS(1); + if (index < 0) + { + index = src.Length + index; + } + if (index >= src.Length) + { + return 0.0; + } + return Convert.ToDouble(src.Data[index]); + } + + public void osSetParcelMediaURL(string url) + { + if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false)) + { + OSSLError("osSetParcelMediaURL: permission denied"); + return; + } + + m_host.AddScriptLPS(1); + LLUUID landowner = World.GetLandOwner(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y); + + if (landowner == LLUUID.Zero) + { + return; + } + + if (landowner != m_host.ObjectOwner) + { + return; + } + + World.SetLandMediaURL(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, url); + } + + public Scene World + { + get { return m_ScriptEngine.World; } + } + + internal void OSSLError(string msg) + { + throw new Exception("OSSL Runtime Error: " + msg); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Dataserver.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Dataserver.cs new file mode 100644 index 0000000..6c88ae86 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Dataserver.cs @@ -0,0 +1,128 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections; +using System.Collections.Generic; +using libsecondlife; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.ScriptEngine.Shared.Api; + +namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins +{ + public class Dataserver + { + public AsyncCommandManager m_CmdManager; + + private Dictionary DataserverRequests = + new Dictionary(); + + public Dataserver(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + private class DataserverRequest + { + public uint localID; + public LLUUID itemID; + + public LLUUID ID; + public string handle; + + public DateTime startTime; + } + + public LLUUID RegisterRequest(uint localID, LLUUID itemID, + string identifier) + { + lock (DataserverRequests) + { + if (DataserverRequests.ContainsKey(identifier)) + return LLUUID.Zero; + + DataserverRequest ds = new DataserverRequest(); + + ds.localID = localID; + ds.itemID = itemID; + + ds.ID = LLUUID.Random(); + ds.handle = identifier; + + ds.startTime = DateTime.Now; + + DataserverRequests[identifier]=ds; + + return ds.ID; + } + } + + public void DataserverReply(string identifier, string reply) + { + DataserverRequest ds; + + lock (DataserverRequests) + { + if (!DataserverRequests.ContainsKey(identifier)) + return; + + ds=DataserverRequests[identifier]; + DataserverRequests.Remove(identifier); + } + + m_CmdManager.m_ScriptEngine.PostObjectEvent(ds.localID, + new EventParams("dataserver", new Object[] + { new LSL_Types.LSLString(ds.ID.ToString()), + new LSL_Types.LSLString(reply)}, + new DetectParams[0])); + } + + public void RemoveEvents(uint localID, LLUUID itemID) + { + lock (DataserverRequests) + { + foreach (DataserverRequest ds in new List(DataserverRequests.Values)) + { + if (ds.itemID == itemID) + DataserverRequests.Remove(ds.handle); + } + } + } + + public void ExpireRequests() + { + lock (DataserverRequests) + { + foreach (DataserverRequest ds in new List(DataserverRequests.Values)) + { + if (ds.startTime > DateTime.Now.AddSeconds(30)) + DataserverRequests.Remove(ds.handle); + } + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/HttpRequest.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/HttpRequest.cs new file mode 100644 index 0000000..92f603d --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/HttpRequest.cs @@ -0,0 +1,91 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using OpenSim.Region.Environment.Interfaces; +using OpenSim.Region.Environment.Modules.Scripting.HttpRequest; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.ScriptEngine.Interfaces; +using OpenSim.Region.ScriptEngine.Shared.Api; + +namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins +{ + public class HttpRequest + { + public AsyncCommandManager m_CmdManager; + + public HttpRequest(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + public void CheckHttpRequests() + { + if (m_CmdManager.m_ScriptEngine.World == null) + return; + + IHttpRequests iHttpReq = + m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); + + HttpRequestClass httpInfo = null; + + if (iHttpReq != null) + httpInfo = iHttpReq.GetNextCompletedRequest(); + + while (httpInfo != null) + { + //m_ScriptEngine.Log.Info("[AsyncLSL]:" + httpInfo.response_body + httpInfo.status); + + // Deliver data to prim's remote_data handler + // + // TODO: Returning null for metadata, since the lsl function + // only returns the byte for HTTP_BODY_TRUNCATED, which is not + // implemented here yet anyway. Should be fixed if/when maxsize + // is supported + + iHttpReq.RemoveCompletedRequest(httpInfo.reqID); + + object[] resobj = new object[] + { + new LSL_Types.LSLString(httpInfo.reqID.ToString()), + new LSL_Types.LSLInteger(httpInfo.status), + new LSL_Types.list(), + new LSL_Types.LSLString(httpInfo.response_body) + }; + + foreach (AsyncCommandManager m in m_CmdManager.Managers) + { + if (m.m_ScriptEngine.PostObjectEvent(httpInfo.localID, + new EventParams("http_response", + resobj, new DetectParams[0]))) + break; + } + httpInfo = iHttpReq.GetNextCompletedRequest(); + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Listener.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Listener.cs new file mode 100644 index 0000000..11b45b1 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Listener.cs @@ -0,0 +1,92 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using libsecondlife; +using OpenSim.Region.Environment.Interfaces; +using OpenSim.Region.Environment.Modules.Scripting.WorldComm; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.ScriptEngine.Shared.Api; + +namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins +{ + public class Listener + { + // private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); + + public AsyncCommandManager m_CmdManager; + + public Listener(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + public void CheckListeners() + { + if (m_CmdManager.m_ScriptEngine.World == null) + return; + IWorldComm comms = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); + + if (comms != null) + { + while (comms.HasMessages()) + { + ListenerInfo lInfo = comms.GetNextMessage(); + + //Deliver data to prim's listen handler + object[] resobj = new object[] + { + new LSL_Types.LSLInteger(lInfo.GetChannel()), + new LSL_Types.LSLString(lInfo.GetName()), + new LSL_Types.LSLString(lInfo.GetID().ToString()), + new LSL_Types.LSLString(lInfo.GetMessage()) + }; + + m_CmdManager.m_ScriptEngine.PostScriptEvent( + lInfo.GetItemID(), new EventParams( + "listen", resobj, + new DetectParams[0])); + } + } + } + + public Object[] GetSerializationData(LLUUID itemID) + { + IWorldComm comms = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); + + return comms.GetSerializationData(itemID); + } + + public void CreateFromData(uint localID, LLUUID itemID, LLUUID hostID, + Object[] data) + { + IWorldComm comms = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); + + comms.CreateFromData(localID, itemID, hostID, data); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs new file mode 100644 index 0000000..5833512 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs @@ -0,0 +1,389 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections.Generic; +using libsecondlife; +using OpenSim.Framework; +using OpenSim.Region.Environment.Scenes; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.ScriptEngine.Shared.Api; + +namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins +{ + public class SensorRepeat + { + public AsyncCommandManager m_CmdManager; + + public SensorRepeat(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + public Dictionary> SenseEvents = + new Dictionary>(); + private Object SenseLock = new Object(); + + // + // SenseRepeater and Sensors + // + private class SenseRepeatClass + { + public uint localID; + public LLUUID itemID; + public double interval; + public DateTime next; + + public string name; + public LLUUID keyID; + public int type; + public double range; + public double arc; + public SceneObjectPart host; + } + + private List SenseRepeaters = new List(); + private object SenseRepeatListLock = new object(); + + public void SetSenseRepeatEvent(uint m_localID, LLUUID m_itemID, + string name, LLUUID keyID, int type, double range, + double arc, double sec, SceneObjectPart host) + { + // Always remove first, in case this is a re-set + UnSetSenseRepeaterEvents(m_localID, m_itemID); + if (sec == 0) // Disabling timer + return; + + // Add to timer + SenseRepeatClass ts = new SenseRepeatClass(); + ts.localID = m_localID; + ts.itemID = m_itemID; + ts.interval = sec; + ts.name = name; + ts.keyID = keyID; + ts.type = type; + ts.range = range; + ts.arc = arc; + ts.host = host; + + ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); + lock (SenseRepeatListLock) + { + SenseRepeaters.Add(ts); + } + } + + public void UnSetSenseRepeaterEvents(uint m_localID, LLUUID m_itemID) + { + // Remove from timer + lock (SenseRepeatListLock) + { + List NewSensors = new List(); + foreach (SenseRepeatClass ts in SenseRepeaters) + { + if (ts.localID != m_localID && ts.itemID != m_itemID) + { + NewSensors.Add(ts); + } + } + SenseRepeaters.Clear(); + SenseRepeaters = NewSensors; + } + } + + public void CheckSenseRepeaterEvents() + { + // Nothing to do here? + if (SenseRepeaters.Count == 0) + return; + + lock (SenseRepeatListLock) + { + // Go through all timers + foreach (SenseRepeatClass ts in SenseRepeaters) + { + // Time has passed? + if (ts.next.ToUniversalTime() < DateTime.Now.ToUniversalTime()) + { + SensorSweep(ts); + // set next interval + ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); + } + } + } // lock + } + + public void SenseOnce(uint m_localID, LLUUID m_itemID, + string name, LLUUID keyID, int type, + double range, double arc, SceneObjectPart host) + { + // Add to timer + SenseRepeatClass ts = new SenseRepeatClass(); + ts.localID = m_localID; + ts.itemID = m_itemID; + ts.interval = 0; + ts.name = name; + ts.keyID = keyID; + ts.type = type; + ts.range = range; + ts.arc = arc; + ts.host = host; + SensorSweep(ts); + } + + public LSL_Types.list GetSensorList(uint m_localID, LLUUID m_itemID) + { + lock (SenseLock) + { + Dictionary Obj = null; + if (!SenseEvents.TryGetValue(m_localID, out Obj)) + { + return null; + } + lock (Obj) + { + // Get script + LSL_Types.list SenseList = null; + if (!Obj.TryGetValue(m_itemID, out SenseList)) + { + return null; + } + return SenseList; + } + } + } + + private void SensorSweep(SenseRepeatClass ts) + { + SceneObjectPart SensePoint = ts.host; + + if (SensePoint == null) + { + return; + } + + LLVector3 sensorPos = SensePoint.AbsolutePosition; + LLVector3 regionPos = new LLVector3(m_CmdManager.m_ScriptEngine.World.RegionInfo.RegionLocX * Constants.RegionSize, m_CmdManager.m_ScriptEngine.World.RegionInfo.RegionLocY * Constants.RegionSize, 0); + LLVector3 fromRegionPos = sensorPos + regionPos; + + LLQuaternion q = SensePoint.RotationOffset; + LSL_Types.Quaternion r = new LSL_Types.Quaternion(q.X, q.Y, q.Z, q.W); + LSL_Types.Vector3 forward_dir = (new LSL_Types.Vector3(1, 0, 0) * r); + double mag_fwd = LSL_Types.Vector3.Mag(forward_dir); + + // Here we should do some smart culling ... + // math seems quicker than strings so try that first + LSL_Types.list SensedObjects = new LSL_Types.list(); + LSL_Types.Vector3 ZeroVector = new LSL_Types.Vector3(0, 0, 0); + + foreach (EntityBase ent in m_CmdManager.m_ScriptEngine.World.Entities.Values) + { + LLVector3 toRegionPos = ent.AbsolutePosition + regionPos; + double dis = Math.Abs((double)Util.GetDistanceTo(toRegionPos, fromRegionPos)); + if (dis <= ts.range) + { + // In Range, is it the right Type ? + int objtype = 0; + + if (m_CmdManager.m_ScriptEngine.World.GetScenePresence(ent.UUID) != null) objtype |= 0x01; // actor + if (ent.Velocity.Equals(ZeroVector)) + objtype |= 0x04; // passive non-moving + else + objtype |= 0x02; // active moving + + SceneObjectPart part = m_CmdManager.m_ScriptEngine.World.GetSceneObjectPart(ent.UUID); + + if (part != null && part.ContainsScripts()) objtype |= 0x08; // Scripted. It COULD have one hidden ... + + if (((ts.type & objtype) != 0) || ((ts.type & objtype) == ts.type)) + { + // docs claim AGENT|ACTIVE should find agent objects OR active objects + // so the bitwise AND with object type should be non-zero + + // Right type too, what about the other params , key and name ? + bool keep = true; + if (ts.arc < Math.PI) + { + // not omni-directional. Can you see it ? + // vec forward_dir = llRot2Fwd(llGetRot()) + // vec obj_dir = toRegionPos-fromRegionPos + // dot=dot(forward_dir,obj_dir) + // mag_fwd = mag(forward_dir) + // mag_obj = mag(obj_dir) + // ang = acos(dot /(mag_fwd*mag_obj)) + double ang_obj = 0; + try + { + LLVector3 diff = toRegionPos - fromRegionPos; + LSL_Types.Vector3 obj_dir = new LSL_Types.Vector3(diff.X, diff.Y, diff.Z); + double dot = LSL_Types.Vector3.Dot(forward_dir, obj_dir); + double mag_obj = LSL_Types.Vector3.Mag(obj_dir); + ang_obj = Math.Acos(dot / (mag_fwd * mag_obj)); + } + catch + { + } + + if (ang_obj > ts.arc) keep = false; + } + + if (keep && (ts.keyID != LLUUID.Zero) && (ts.keyID != ent.UUID)) + { + keep = false; + } + + if (keep && (ts.name.Length > 0)) + { + string avatarname=null; + string objectname=null; + string entname =ent.Name; + + // try avatar username surname + UserProfileData profile = m_CmdManager.m_ScriptEngine.World.CommsManager.UserService.GetUserProfile(ent.UUID); + if (profile != null) + { + avatarname = profile.FirstName + " " + profile.SurName; + } + // try an scene object + SceneObjectPart SOP = m_CmdManager.m_ScriptEngine.World.GetSceneObjectPart(ent.UUID); + if (SOP != null) + { + objectname = SOP.Name; + } + + if ((ts.name != entname) && (ts.name != avatarname) && (ts.name != objectname)) + { + keep = false; + } + } + + if (keep == true) SensedObjects.Add(ent.UUID); + } + } + } + + lock (SenseLock) + { + // Create object if it doesn't exist + if (SenseEvents.ContainsKey(ts.localID) == false) + { + SenseEvents.Add(ts.localID, new Dictionary()); + } + // clear if previous traces exist + Dictionary Obj; + SenseEvents.TryGetValue(ts.localID, out Obj); + if (Obj.ContainsKey(ts.itemID) == true) + Obj.Remove(ts.itemID); + + // note list may be zero length + Obj.Add(ts.itemID, SensedObjects); + + if (SensedObjects.Length == 0) + { + // send a "no_sensor" + // Add it to queue + m_CmdManager.m_ScriptEngine.PostScriptEvent(ts.itemID, + new EventParams("no_sensor", new Object[0], + new DetectParams[0])); + } + else + { + DetectParams[] detect = + new DetectParams[SensedObjects.Length]; + + int idx; + for (idx = 0; idx < SensedObjects.Length; idx++) + { + detect[idx] = new DetectParams(); + detect[idx].Key=(LLUUID)(SensedObjects.Data[idx]); + detect[idx].Populate(m_CmdManager.m_ScriptEngine.World); + } + + m_CmdManager.m_ScriptEngine.PostScriptEvent(ts.itemID, + new EventParams("sensor", + new Object[] { + new LSL_Types.LSLInteger(SensedObjects.Length) }, + detect)); + } + } + } + + public Object[] GetSerializationData(LLUUID itemID) + { + List data = new List(); + + foreach (SenseRepeatClass ts in SenseRepeaters) + { + if (ts.itemID == itemID) + { + data.Add(ts.interval); + data.Add(ts.name); + data.Add(ts.keyID); + data.Add(ts.type); + data.Add(ts.range); + data.Add(ts.arc); + } + } + return data.ToArray(); + } + + public void CreateFromData(uint localID, LLUUID itemID, LLUUID objectID, + Object[] data) + { + SceneObjectPart part = + m_CmdManager.m_ScriptEngine.World.GetSceneObjectPart( + objectID); + + if (part == null) + return; + + int idx = 0; + + while (idx < data.Length) + { + SenseRepeatClass ts = new SenseRepeatClass(); + + ts.localID = localID; + ts.itemID = itemID; + + ts.interval = (double)data[idx]; + ts.name = (string)data[idx+1]; + ts.keyID = (LLUUID)data[idx+2]; + ts.type = (int)data[idx+3]; + ts.range = (double)data[idx+4]; + ts.arc = (double)data[idx+5]; + ts.host = part; + + ts.next = + DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); + + SenseRepeaters.Add(ts); + idx += 6; + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Timer.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Timer.cs new file mode 100644 index 0000000..36e992b --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Timer.cs @@ -0,0 +1,162 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections; +using System.Collections.Generic; +using libsecondlife; +using OpenSim.Region.ScriptEngine.Shared.Api; + +namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins +{ + public class Timer + { + public AsyncCommandManager m_CmdManager; + + public Timer(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + // + // TIMER + // + private class TimerClass + { + public uint localID; + public LLUUID itemID; + //public double interval; + public long interval; + //public DateTime next; + public long next; + } + + private List Timers = new List(); + private object TimerListLock = new object(); + + public void SetTimerEvent(uint m_localID, LLUUID m_itemID, double sec) + { + // Always remove first, in case this is a re-set + UnSetTimerEvents(m_localID, m_itemID); + if (sec == 0) // Disabling timer + return; + + // Add to timer + TimerClass ts = new TimerClass(); + ts.localID = m_localID; + ts.itemID = m_itemID; + ts.interval = Convert.ToInt64(sec * 10000000); // How many 100 nanoseconds (ticks) should we wait + // 2193386136332921 ticks + // 219338613 seconds + + //ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); + ts.next = DateTime.Now.Ticks + ts.interval; + lock (TimerListLock) + { + Timers.Add(ts); + } + } + + public void UnSetTimerEvents(uint m_localID, LLUUID m_itemID) + { + // Remove from timer + lock (TimerListLock) + { + foreach (TimerClass ts in new ArrayList(Timers)) + { + if (ts.localID == m_localID && ts.itemID == m_itemID) + Timers.Remove(ts); + } + } + } + + public void CheckTimerEvents() + { + // Nothing to do here? + if (Timers.Count == 0) + return; + + lock (TimerListLock) + { + // Go through all timers + foreach (TimerClass ts in Timers) + { + // Time has passed? + if (ts.next < DateTime.Now.Ticks) + { + // Console.WriteLine("Time has passed: Now: " + DateTime.Now.Ticks + ", Passed: " + ts.next); + // Add it to queue + m_CmdManager.m_ScriptEngine.PostScriptEvent(ts.itemID, + new EventParams("timer", new Object[0], + new DetectParams[0])); + // set next interval + + //ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); + ts.next = DateTime.Now.Ticks + ts.interval; + } + } + } + } + + public Object[] GetSerializationData(LLUUID itemID) + { + List data = new List(); + + lock (TimerListLock) + { + foreach (TimerClass ts in Timers) + { + if (ts.itemID == itemID) + { + data.Add(ts.interval); + data.Add(ts.next-DateTime.Now.Ticks); + } + } + } + return data.ToArray(); + } + + public void CreateFromData(uint localID, LLUUID itemID, LLUUID objectID, + Object[] data) + { + int idx = 0; + + while (idx < data.Length) + { + TimerClass ts = new TimerClass(); + + ts.localID = localID; + ts.itemID = itemID; + ts.interval = (long)data[idx]; + ts.next = DateTime.Now.Ticks + (long)data[idx+1]; + idx += 2; + + Timers.Add(ts); + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/XmlRequest.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/XmlRequest.cs new file mode 100644 index 0000000..89bf51c --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/XmlRequest.cs @@ -0,0 +1,117 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using OpenSim.Region.Environment.Interfaces; +using OpenSim.Region.Environment.Modules.Scripting.XMLRPC; +using OpenSim.Region.ScriptEngine.Interfaces; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.ScriptEngine.Shared.Api; + +namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins +{ + public class XmlRequest + { + public AsyncCommandManager m_CmdManager; + + public XmlRequest(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + public void CheckXMLRPCRequests() + { + if (m_CmdManager.m_ScriptEngine.World == null) + return; + + IXMLRPC xmlrpc = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); + + if (xmlrpc != null) + { + RPCRequestInfo rInfo = xmlrpc.GetNextCompletedRequest(); + + while (rInfo != null) + { + xmlrpc.RemoveCompletedRequest(rInfo.GetMessageID()); + + //Deliver data to prim's remote_data handler + object[] resobj = new object[] + { + new LSL_Types.LSLInteger(2), + new LSL_Types.LSLString( + rInfo.GetChannelKey().ToString()), + new LSL_Types.LSLString( + rInfo.GetMessageID().ToString()), + new LSL_Types.LSLString(String.Empty), + new LSL_Types.LSLInteger(rInfo.GetIntValue()), + new LSL_Types.LSLString(rInfo.GetStrVal()) + }; + + foreach (AsyncCommandManager m in m_CmdManager.Managers) + { + if (m.m_ScriptEngine.PostScriptEvent( + rInfo.GetItemID(), new EventParams( + "remote_data", resobj, + new DetectParams[0]))) + break; + } + + rInfo = xmlrpc.GetNextCompletedRequest(); + } + + SendRemoteDataRequest srdInfo = xmlrpc.GetNextCompletedSRDRequest(); + + while (srdInfo != null) + { + xmlrpc.RemoveCompletedSRDRequest(srdInfo.GetReqID()); + + //Deliver data to prim's remote_data handler + object[] resobj = new object[] + { + new LSL_Types.LSLInteger(3), + new LSL_Types.LSLString(srdInfo.channel.ToString()), + new LSL_Types.LSLString(srdInfo.GetReqID().ToString()), + new LSL_Types.LSLString(String.Empty), + new LSL_Types.LSLInteger(srdInfo.idata), + new LSL_Types.LSLString(srdInfo.sdata) + }; + + foreach (AsyncCommandManager m in m_CmdManager.Managers) + { + if (m.m_ScriptEngine.PostScriptEvent( + srdInfo.m_itemID, new EventParams( + "remote_data", resobj, + new DetectParams[0]))) + break; + } + + srdInfo = xmlrpc.GetNextCompletedSRDRequest(); + } + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs new file mode 100644 index 0000000..75672a1 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs @@ -0,0 +1,649 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3; +using rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion; + + +namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces +{ + public interface ILSL_Api + { + void state(string newState); + void llSay(int channelID, string text); + double llSin(double f); + double llCos(double f); + double llTan(double f); + double llAtan2(double x, double y); + double llSqrt(double f); + double llPow(double fbase, double fexponent); + LSL_Types.LSLInteger llAbs(int i); + double llFabs(double f); + double llFrand(double mag); + LSL_Types.LSLInteger llFloor(double f); + LSL_Types.LSLInteger llCeil(double f); + LSL_Types.LSLInteger llRound(double f); + double llVecMag(LSL_Types.Vector3 v); + LSL_Types.Vector3 llVecNorm(LSL_Types.Vector3 v); + double llVecDist(LSL_Types.Vector3 a, LSL_Types.Vector3 b); + LSL_Types.Vector3 llRot2Euler(LSL_Types.Quaternion r); + LSL_Types.Quaternion llEuler2Rot(LSL_Types.Vector3 v); + LSL_Types.Quaternion llAxes2Rot(LSL_Types.Vector3 fwd, LSL_Types.Vector3 left, LSL_Types.Vector3 up); + LSL_Types.Vector3 llRot2Fwd(LSL_Types.Quaternion r); + LSL_Types.Vector3 llRot2Left(LSL_Types.Quaternion r); + LSL_Types.Vector3 llRot2Up(LSL_Types.Quaternion r); + LSL_Types.Quaternion llRotBetween(LSL_Types.Vector3 start, LSL_Types.Vector3 end); + void llWhisper(int channelID, string text); + //void llSay(int channelID, string text); + void llShout(int channelID, string text); + void llRegionSay(int channelID, string text); + LSL_Types.LSLInteger llListen(int channelID, string name, string ID, string msg); + void llListenControl(int number, int active); + void llListenRemove(int number); + void llSensor(string name, string id, int type, double range, double arc); + void llSensorRepeat(string name, string id, int type, double range, double arc, double rate); + void llSensorRemove(); + string llDetectedName(int number); + string llDetectedKey(int number); + string llDetectedOwner(int number); + LSL_Types.LSLInteger llDetectedType(int number); + LSL_Types.Vector3 llDetectedPos(int number); + LSL_Types.Vector3 llDetectedVel(int number); + LSL_Types.Vector3 llDetectedGrab(int number); + LSL_Types.Quaternion llDetectedRot(int number); + LSL_Types.LSLInteger llDetectedGroup(int number); + LSL_Types.LSLInteger llDetectedLinkNumber(int number); + void llDie(); + double llGround(LSL_Types.Vector3 offset); + double llCloud(LSL_Types.Vector3 offset); + LSL_Types.Vector3 llWind(LSL_Types.Vector3 offset); + void llSetStatus(int status, int value); + LSL_Types.LSLInteger llGetStatus(int status); + void llSetScale(LSL_Types.Vector3 scale); + LSL_Types.Vector3 llGetScale(); + void llSetColor(LSL_Types.Vector3 color, int face); + double llGetAlpha(int face); + void llSetAlpha(double alpha, int face); + LSL_Types.Vector3 llGetColor(int face); + void llSetTexture(string texture, int face); + void llScaleTexture(double u, double v, int face); + void llOffsetTexture(double u, double v, int face); + void llRotateTexture(double rotation, int face); + string llGetTexture(int face); + void llSetPos(LSL_Types.Vector3 pos); + + //wiki: vector llGetPos() + LSL_Types.Vector3 llGetPos(); + //wiki: vector llGetLocalPos() + LSL_Types.Vector3 llGetLocalPos(); + //wiki: llSetRot(rotation rot) + void llSetRot(LSL_Types.Quaternion rot); + //wiki: rotation llGetRot() + LSL_Types.Quaternion llGetRot(); + //wiki: rotation llGetLocalRot() + LSL_Types.Quaternion llGetLocalRot(); + //wiki: llSetForce(vector force, integer local) + void llSetForce(LSL_Types.Vector3 force, int local); + //wiki: vector llGetForce() + LSL_Types.Vector3 llGetForce(); + //wiki: integer llTarget(vector position, double range) + LSL_Types.LSLInteger llTarget(LSL_Types.Vector3 position, double range); + //wiki: llTargetRemove(integer number) + void llTargetRemove(int number); + //wiki: integer llRotTarget(rotation rot, double error) + LSL_Types.LSLInteger llRotTarget(LSL_Types.Quaternion rot, double error); + //wiki: integer llRotTargetRemove(integer number) + void llRotTargetRemove(int number); + //wiki: llMoveToTarget(vector target, double tau) + void llMoveToTarget(LSL_Types.Vector3 target, double tau); + //wiki: llStopMoveToTarget() + void llStopMoveToTarget(); + //wiki: llApplyImpulse(vector force, integer local) + void llApplyImpulse(LSL_Types.Vector3 force, int local); + //wiki: llapplyRotationalImpulse(vector force, integer local) + void llApplyRotationalImpulse(LSL_Types.Vector3 force, int local); + //wiki: llSetTorque(vector torque, integer local) + void llSetTorque(LSL_Types.Vector3 torque, int local); + //wiki: vector llGetTorque() + LSL_Types.Vector3 llGetTorque(); + //wiki: llSeForceAndTorque(vector force, vector torque, integer local) + void llSetForceAndTorque(LSL_Types.Vector3 force, LSL_Types.Vector3 torque, int local); + //wiki: vector llGetVel() + LSL_Types.Vector3 llGetVel(); + //wiki: vector llGetAccel() + LSL_Types.Vector3 llGetAccel(); + //wiki: vector llGetOmega() + LSL_Types.Vector3 llGetOmega(); + //wiki: double llGetTimeOfDay() + double llGetTimeOfDay(); + //wiki: double llGetWallclock() + double llGetWallclock(); + //wiki: double llGetTime() + double llGetTime(); + //wiki: llResetTime() + void llResetTime(); + //wiki: double llGetAndResetTime() + double llGetAndResetTime(); + //wiki (deprecated) llSound(string sound, double volume, integer queue, integer loop) + void llSound(); + //wiki: llPlaySound(string sound, double volume) + void llPlaySound(string sound, double volume); + //wiki: llLoopSound(string sound, double volume) + void llLoopSound(string sound, double volume); + //wiki: llLoopSoundMaster(string sound, double volume) + void llLoopSoundMaster(string sound, double volume); + //wiki: llLoopSoundSlave(string sound, double volume) + void llLoopSoundSlave(string sound, double volume); + //wiki llPlaySoundSlave(string sound, double volume) + void llPlaySoundSlave(string sound, double volume); + //wiki: llTriggerSound(string sound, double volume) + void llTriggerSound(string sound, double volume); + //wiki: llStopSound() + void llStopSound(); + //wiki: llPreloadSound(string sound) + void llPreloadSound(string sound); + //wiki: string llGetSubString(string src, integer start, integer end) + string llGetSubString(string src, int start, int end); + //wiki: string llDeleteSubString(string src, integer start, integer end) + string llDeleteSubString(string src, int start, int end); + //wiki string llInsertString(string dst, integer position, string src) + string llInsertString(string dst, int position, string src); + //wiki: string llToUpper(string source) + string llToUpper(string source); + //wiki: string llToLower(string source) + string llToLower(string source); + //wiki: integer llGiveMoney(key destination, integer amount) + LSL_Types.LSLInteger llGiveMoney(string destination, int amount); + //wiki: (deprecated) + void llMakeExplosion(); + //wiki: (deprecated) + void llMakeFountain(); + //wiki: (deprecated) + void llMakeSmoke(); + //wiki: (deprecated) + void llMakeFire(); + //wiki: llRezObject(string inventory, vector pos, vector rel, rotation rot, integer param) + void llRezObject(string inventory, LSL_Types.Vector3 pos, LSL_Types.Vector3 vel, LSL_Types.Quaternion rot, int param); + //wiki: llLookAt(vector target, double strength, double damping) + void llLookAt(LSL_Types.Vector3 target, double strength, double damping); + //wiki: llStopLookAt() + void llStopLookAt(); + //wiki: llSetTimerEvent(double sec) + void llSetTimerEvent(double sec); + //wiki: llSleep(double sec) + void llSleep(double sec); + //wiki: double llGetMass() + double llGetMass(); + //wiki: llCollisionFilter(string name, key id, integer accept) + void llCollisionFilter(string name, string id, int accept); + //wiki: llTakeControls(integer controls, integer accept, integer pass_on) + void llTakeControls(int controls, int accept, int pass_on); + //wiki: llReleaseControls() + void llReleaseControls(); + //wiki: llAttachToAvatar(integer attachment) + void llAttachToAvatar(int attachment); + //wiki: llDetachFromAvatar() + void llDetachFromAvatar(); + //wiki: (deprecated) llTakeCamera() + void llTakeCamera(); + //wiki: (deprecated) llReleaseCamera() + void llReleaseCamera(); + //wiki: key llGetOwner() + string llGetOwner(); + //wiki: llInstantMessage(key user, string message) + void llInstantMessage(string user, string message); + //wiki: llEmail(string address, string subject, string message) + void llEmail(string address, string subject, string message); + //wiki: llGetNextEmail(string address, string subject) + void llGetNextEmail(string address, string subject); + //wiki: key llGetKey() + string llGetKey(); + //wiki: llSetBuoyancy(double buoyancy) + void llSetBuoyancy(double buoyancy); + //wiki: llSetHoverHeight(double height, integer water, double tau) + void llSetHoverHeight(double height, int water, double tau); + //wiki: llStopHover + void llStopHover(); + //wiki: llMinEventDelay(double delay) + void llMinEventDelay(double delay); + //wiki: (deprecated) llSoundPreload() + void llSoundPreload(); + //wiki: llRotLookAt(rotation target, double strength, double damping) + void llRotLookAt(LSL_Types.Quaternion target, double strength, double damping); + //wiki: integer llStringLength(string str) + LSL_Types.LSLInteger llStringLength(string str); + //wiki: llStartAnimation(string anim) + void llStartAnimation(string anim); + //wiki: llStopAnimation(string anim) + void llStopAnimation(string anim); + //wiki: (deprecated) llPointAt + void llPointAt(); + //wiki: (deprecated) llStopPointAt + void llStopPointAt(); + //wiki: llTargetOmega(vector axis, double spinrate, double gain) + void llTargetOmega(LSL_Types.Vector3 axis, double spinrate, double gain); + //wiki: integer llGetStartParameter() + LSL_Types.LSLInteger llGetStartParameter(); + //wiki: llGodLikeRezObject(key inventory, vector pos) + void llGodLikeRezObject(string inventory, LSL_Types.Vector3 pos); + //wiki: llRequestPermissions(key agent, integer perm) + void llRequestPermissions(string agent, int perm); + //wiki: key llGetPermissionsKey() + string llGetPermissionsKey(); + //wiki: integer llGetPermissions() + LSL_Types.LSLInteger llGetPermissions(); + //wiki integer llGetLinkNumber() + LSL_Types.LSLInteger llGetLinkNumber(); + //wiki: llSetLinkColor(integer linknumber, vector color, integer face) + void llSetLinkColor(int linknumber, LSL_Types.Vector3 color, int face); + //wiki: llCreateLink(key target, integer parent) + void llCreateLink(string target, int parent); + //wiki: llBreakLink(integer linknum) + void llBreakLink(int linknum); + //wiki: llBreakAllLinks() + void llBreakAllLinks(); + //wiki: key llGetLinkKey(integer linknum) + string llGetLinkKey(int linknum); + //wiki: llGetLinkName(integer linknum) + string llGetLinkName(int linknum); + //wiki: integer llGetInventoryNumber(integer type) + LSL_Types.LSLInteger llGetInventoryNumber(int type); + //wiki: string llGetInventoryName(integer type, integer number) + string llGetInventoryName(int type, int number); + //wiki: llSetScriptState(string name, integer run) + void llSetScriptState(string name, int run); + //wiki: double llGetEnergy() + double llGetEnergy(); + //wiki: llGiveInventory(key destination, string inventory) + void llGiveInventory(string destination, string inventory); + //wiki: llRemoveInventory(string item) + void llRemoveInventory(string item); + //wiki: llSetText(string text, vector color, double alpha) + void llSetText(string text, LSL_Types.Vector3 color, double alpha); + //wiki: double llWater(vector offset) + double llWater(LSL_Types.Vector3 offset); + //wiki: llPassTouches(integer pass) + void llPassTouches(int pass); + //wiki: key llRequestAgentData(key id, integer data) + string llRequestAgentData(string id, int data); + //wiki: key llRequestInventoryData(string name) + string llRequestInventoryData(string name); + //wiki: llSetDamage(double damage) + void llSetDamage(double damage); + //wiki: llTeleportAgentHome(key agent) + void llTeleportAgentHome(string agent); + //wiki: llModifyLand(integer action, integer brush) + void llModifyLand(int action, int brush); + //wiki: llCollisionSound(string impact_sound, double impact_volume) + void llCollisionSound(string impact_sound, double impact_volume); + //wiki: llCollisionSprite(string impact_sprite) + void llCollisionSprite(string impact_sprite); + //wiki: string llGetAnimation(key id) + string llGetAnimation(string id); + //wiki: llResetScript() + void llResetScript(); + //wiki: llMessageLinked(integer linknum, integer num, string str, key id) + void llMessageLinked(int linknum, int num, string str, string id); + //wiki: llPushObject(key target, vector impulse, vector ang_impulse, integer local) + void llPushObject(string target, LSL_Types.Vector3 impulse, LSL_Types.Vector3 ang_impulse, int local); + //wiki: llPassCollisions(integer pass) + void llPassCollisions(int pass); + //wiki: string llGetScriptName() + string llGetScriptName(); + //wiki: integer llGetNumberOfSides() + LSL_Types.LSLInteger llGetNumberOfSides(); + //wiki: rotation llAxisAngle2Rot(vector axis, double angle) + LSL_Types.Quaternion llAxisAngle2Rot(LSL_Types.Vector3 axis, double angle); + //wiki: vector llRot2Axis(rotation rot) + LSL_Types.Vector3 llRot2Axis(LSL_Types.Quaternion rot); + //wiki: double llRot2Angle(rotation rot); + double llRot2Angle(LSL_Types.Quaternion rot); + //wiki: double llAcos(double val) + double llAcos(double val); + //wiki: double llAsin(double val) + double llAsin(double val); + //wiki: double llAngleBetween(rotation a, rotation b) + double llAngleBetween(LSL_Types.Quaternion a, LSL_Types.Quaternion b); + //wiki: string llGetInventoryKey(string name) + string llGetInventoryKey(string name); + //wiki: llAllowInventoryDrop(integer add) + void llAllowInventoryDrop(int add); + //wiki: vector llGetSunDirection() + LSL_Types.Vector3 llGetSunDirection(); + //wiki: vector llGetTextureOffset(integer face) + LSL_Types.Vector3 llGetTextureOffset(int face); + //wiki: vector llGetTextureScale(integer side) + LSL_Types.Vector3 llGetTextureScale(int side); + //wiki: double llGetTextureRot(integer side) + double llGetTextureRot(int side); + //wiki: integer llSubStringIndex(string source, string pattern) + LSL_Types.LSLInteger llSubStringIndex(string source, string pattern); + //wiki: key llGetOwnerKey(key id) + string llGetOwnerKey(string id); + //wiki: vector llGetCenterOfMass() + LSL_Types.Vector3 llGetCenterOfMass(); + //wiki: list llListSort(list src, integer stride, integer ascending) + LSL_Types.list llListSort(LSL_Types.list src, int stride, int ascending); + //integer llGetListLength(list src) + LSL_Types.LSLInteger llGetListLength(LSL_Types.list src); + //wiki: integer llList2Integer(list src, integer index) + LSL_Types.LSLInteger llList2Integer(LSL_Types.list src, int index); + //wiki: double llList2double(list src, integer index) + double llList2Float(LSL_Types.list src, int index); + //wiki: string llList2String(list src, integer index) + string llList2String(LSL_Types.list src, int index); + //wiki: key llList2Key(list src, integer index) + string llList2Key(LSL_Types.list src, int index); + //wiki: vector llList2Vector(list src, integer index) + LSL_Types.Vector3 llList2Vector(LSL_Types.list src, int index); + //wiki rotation llList2Rot(list src, integer index) + LSL_Types.Quaternion llList2Rot(LSL_Types.list src, int index); + //wiki: list llList2List(list src, integer start, integer end) + LSL_Types.list llList2List(LSL_Types.list src, int start, int end); + //wiki: llDeleteSubList(list src, integer start, integer end) + LSL_Types.list llDeleteSubList(LSL_Types.list src, int start, int end); + //wiki: integer llGetListEntryType(list src, integer index) + LSL_Types.LSLInteger llGetListEntryType(LSL_Types.list src, int index); + //wiki: string llList2CSV(list src) + string llList2CSV(LSL_Types.list src); + //wiki: list llCSV2List(string src) + LSL_Types.list llCSV2List(string src); + //wiki: list llListRandomize(list src, integer stride) + LSL_Types.list llListRandomize(LSL_Types.list src, int stride); + //wiki: list llList2ListStrided(list src, integer start, integer end, integer stride) + LSL_Types.list llList2ListStrided(LSL_Types.list src, int start, int end, int stride); + //wiki: vector llGetRegionCorner() + LSL_Types.Vector3 llGetRegionCorner(); + //wiki: list llListInsertList(list dest, list src, integer start) + LSL_Types.list llListInsertList(LSL_Types.list dest, LSL_Types.list src, int start); + //wiki: integer llListFindList(list src, list test) + LSL_Types.LSLInteger llListFindList(LSL_Types.list src, LSL_Types.list test); + //wiki: string llGetObjectName() + string llGetObjectName(); + //wiki: llSetObjectName(string name) + void llSetObjectName(string name); + //wiki: string llGetDate() + string llGetDate(); + //wiki: integer llEdgeOfWorld(vector pos, vector dir) + LSL_Types.LSLInteger llEdgeOfWorld(LSL_Types.Vector3 pos, LSL_Types.Vector3 dir); + //wiki: integer llGetAgentInfo(key id) + LSL_Types.LSLInteger llGetAgentInfo(string id); + //wiki: llAdjustSoundVolume(double volume) + void llAdjustSoundVolume(double volume); + //wiki: llSetSoundQueueing(integer queue) + void llSetSoundQueueing(int queue); + //wiki: llSetSoundRadius(double radius) + void llSetSoundRadius(double radius); + //wiki: string llKey2Name(key id) + string llKey2Name(string id); + //wiki: llSetTextureAnim(integer mode, integer face, integer sizex, integer sizey, double start, double length, double rate) + void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate); + //wiki: llTriggerSoundLimited(string sound, double volume, vector top_north_east, vector bottom_south_west) + void llTriggerSoundLimited(string sound, double volume, LSL_Types.Vector3 top_north_east, + LSL_Types.Vector3 bottom_south_west); + + //wiki: llEjectFromLand(key pest) + void llEjectFromLand(string pest); + LSL_Types.list llParseString2List(string str, LSL_Types.list separators, LSL_Types.list spacers); + //wiki: integer llOverMyLand(key id) + LSL_Types.LSLInteger llOverMyLand(string id); + //wiki: key llGetLandOwnerAt(vector pos) + string llGetLandOwnerAt(LSL_Types.Vector3 pos); + //wiki: key llGetNotecardLine(string name, integer line) + string llGetNotecardLine(string name, int line); + //wiki: vector llGetAgentSize(key id) + LSL_Types.Vector3 llGetAgentSize(string id); + //wiki: integer llSameGroup(key agent) + LSL_Types.LSLInteger llSameGroup(string agent); + //wiki: llUnSit(key id) + void llUnSit(string id); + //wiki: vector llGroundSlope(vector offset) + LSL_Types.Vector3 llGroundSlope(LSL_Types.Vector3 offset); + //wiki: vector llGroundNormal(vector offset) + LSL_Types.Vector3 llGroundNormal(LSL_Types.Vector3 offset); + //wiki: vector llGroundContour(vector offset) + LSL_Types.Vector3 llGroundContour(LSL_Types.Vector3 offset); + //wiki: integer llGetAttached() + LSL_Types.LSLInteger llGetAttached(); + //wiki: integer llGetFreeMemory() + LSL_Types.LSLInteger llGetFreeMemory(); + //wiki: string llGetRegionName() + string llGetRegionName(); + //wiki: double llGetRegionTimeDilation() + double llGetRegionTimeDilation(); + //wiki: double llGetRegionFPS() + double llGetRegionFPS(); + //wiki: llParticleSystem(List rules + void llParticleSystem(LSL_Types.list rules); + //wiki: llGroundRepel(double height, integer water, double tau) + void llGroundRepel(double height, int water, double tau); + //wiki: llGiveInventoryList(string destination, string category, LSL_Types.list inventory) + void llGiveInventoryList(string destination, string category, LSL_Types.list inventory); + //wiki: llSetVehicleType(integer type) + void llSetVehicleType(int type); + //wiki: llSetVehicledoubleParam(integer param, double value) + void llSetVehicledoubleParam(int param, double value); + // wiki: llSetVehicleFloatParam(integer param, float value) + void llSetVehicleFloatParam(int param, float value); + //wiki: llSetVehicleVectorParam(integer param, vector vec) + void llSetVehicleVectorParam(int param, LSL_Types.Vector3 vec); + //wiki: llSetVehicleRotationParam(integer param, rotation rot) + void llSetVehicleRotationParam(int param, LSL_Types.Quaternion rot); + //wiki: llSetVehicleFlags(integer flags) + void llSetVehicleFlags(int flags); + //wiki: llRemoveVehicleFlags(integer flags) + void llRemoveVehicleFlags(int flags); + //wiki: llSitTarget(vector offset, rotation rot) + void llSitTarget(LSL_Types.Vector3 offset, LSL_Types.Quaternion rot); + //wiki key llAvatarOnSitTarget() + string llAvatarOnSitTarget(); + //wiki: llAddToLandPassList(key avatar, double hours) + void llAddToLandPassList(string avatar, double hours); + //wiki: llSetTouchText(string text) + void llSetTouchText(string text); + //wiki: llSetSitText(string text) + void llSetSitText(string text); + //wiki: llSetCameraEyeOffset(vector offset) + void llSetCameraEyeOffset(LSL_Types.Vector3 offset); + //wiki: llSeteCameraAtOffset(vector offset) + void llSetCameraAtOffset(LSL_Types.Vector3 offset); + // + string llDumpList2String(LSL_Types.list src, string seperator); + //wiki: integer llScriptDanger(vector pos) + LSL_Types.LSLInteger llScriptDanger(LSL_Types.Vector3 pos); + //wiki: llDialog(key avatar, string message, list buttons, integer chat_channel) + void llDialog(string avatar, string message, LSL_Types.list buttons, int chat_channel); + //wiki: llVolumeDetect(integer detect) + void llVolumeDetect(int detect); + //wiki: llResetOtherScript(string name) + void llResetOtherScript(string name); + //wiki: integer llGetScriptState(string name) + LSL_Types.LSLInteger llGetScriptState(string name); + //wiki: (deprecated) + void llRemoteLoadScript(); + //wiki: llSetRemoteScriptAccessPin(integer pin) + void llSetRemoteScriptAccessPin(int pin); + //wiki: llRemoteLoadScriptPin(key target, string name, integer pin, integer running, integer start_param) + void llRemoteLoadScriptPin(string target, string name, int pin, int running, int start_param); + //wiki: llOpenRemoteDataChannel() + void llOpenRemoteDataChannel(); + //wiki: key llSendRemoteData(key channel, string dest, integer idata, string sdata) + string llSendRemoteData(string channel, string dest, int idata, string sdata); + //wiki: llRemoteDataReply(key channel, key message_id, string sdata, integer idata) + void llRemoteDataReply(string channel, string message_id, string sdata, int idata); + //wiki: llCloseRemoteDataChannel(key channel) + void llCloseRemoteDataChannel(string channel); + //wiki: string llMD5String(string src, integer nonce) + string llMD5String(string src, int nonce); + //wiki: llSetPrimitiveParams(list rules) + void llSetPrimitiveParams(LSL_Types.list rules); + //wiki: llSetLinkPrimitiveParams(integer linknumber, list rules) + void llSetLinkPrimitiveParams(int linknumber, LSL_Types.list rules); + //wiki: string llStringToBase64(string str) + string llStringToBase64(string str); + //wiki: string llBase64ToString(string str) + string llBase64ToString(string str); + //wiki: (deprecated) + void llXorBase64Strings(); + //wiki: llRemoteDataSetRegion() + void llRemoteDataSetRegion(); + //wiki: double llLog10(double val) + double llLog10(double val); + //wiki: double llLog(double val) + double llLog(double val); + //wiki: list llGetAnimationList(key id) + LSL_Types.list llGetAnimationList(string id); + //wiki: llSetParcelMusicURL(string url) + void llSetParcelMusicURL(string url); + //wiki: vector llGetRootPosition() + LSL_Types.Vector3 llGetRootPosition(); + //wiki: rotation llGetRootRotation() + LSL_Types.Quaternion llGetRootRotation(); + //wiki: string llGetObjectDesc() + string llGetObjectDesc(); + //wiki: llSetObjectDesc(string desc) + void llSetObjectDesc(string desc); + //wiki: key llGetCreator() + string llGetCreator(); + //wiki: string llGetTimestamp() + string llGetTimestamp(); + //wiki: llSetLinkAlpha(integer linknumber, double alpha, integer face) + void llSetLinkAlpha(int linknumber, double alpha, int face); + //wiki: integer llGetNumberOfPrims() + LSL_Types.LSLInteger llGetNumberOfPrims(); + //wiki: key llGetNumberOfNotecardLines(string name) + string llGetNumberOfNotecardLines(string name); + //wiki: list llGetBoundingBox(key object) + LSL_Types.list llGetBoundingBox(string obj); + //wiki: vector llGetGeometricCenter() + LSL_Types.Vector3 llGetGeometricCenter(); + //wiki: list llGetPrimitiveParams(list rules) + LSL_Types.list llGetPrimitiveParams(LSL_Types.list rules); + //wiki: string llIntegerToBase64(integer number) + string llIntegerToBase64(int number); + //wiki integer llBase64ToInteger(string str) + LSL_Types.LSLInteger llBase64ToInteger(string str); + //wiki: double llGetGMTclock() + double llGetGMTclock(); + //wiki: string llGetSimulatorHostname() + string llGetSimulatorHostname(); + //llSetLocalRot(rotation rot) + void llSetLocalRot(LSL_Types.Quaternion rot); + //wiki: list llParseStringKeepNulls(string src, list separators, list spacers) + LSL_Types.list llParseStringKeepNulls(string src, LSL_Types.list seperators, LSL_Types.list spacers); + //wiki: llRezAtRoot(string inventory, vector position, vector velocity, rotation rot, integer param) + void llRezAtRoot(string inventory, LSL_Types.Vector3 position, LSL_Types.Vector3 velocity, + LSL_Types.Quaternion rot, int param); + + //wiki: integer llGetObjectPermMask(integer mask) + LSL_Types.LSLInteger llGetObjectPermMask(int mask); + //wiki: llSetObjectPermMask(integer mask, integer value) + void llSetObjectPermMask(int mask, int value); + //wiki integer llGetInventoryPermMask(string item, integer mask) + LSL_Types.LSLInteger llGetInventoryPermMask(string item, int mask); + //wiki: llSetInventoryPermMask(string item, integer mask, integer value) + void llSetInventoryPermMask(string item, int mask, int value); + //wiki: key llGetInventoryCreator(string item) + string llGetInventoryCreator(string item); + //wiki: llOwnerSay(string msg) + void llOwnerSay(string msg); + //wiki: key llRequestSimulatorData(string simulator, integer data) + string llRequestSimulatorData(string simulator, int data); + //wiki: llForceMouselook(integer mouselook) + void llForceMouselook(int mouselook); + //wiki: double llGetObjectMass(key id) + double llGetObjectMass(string id); + LSL_Types.list llListReplaceList(LSL_Types.list dest, LSL_Types.list src, int start, int end); + //wiki: llLoadURL(key avatar_id, string message, string url) + void llLoadURL(string avatar_id, string message, string url); + //wiki: llParcelMediaCommandList(list commandList) + void llParcelMediaCommandList(LSL_Types.list commandList); + void llParcelMediaQuery(); + //wiki integer llModPow(integer a, integer b, integer c) + LSL_Types.LSLInteger llModPow(int a, int b, int c); + //wiki: integer llGetInventoryType(string name) + LSL_Types.LSLInteger llGetInventoryType(string name); + //wiki: llSetPayPrice(integer price, list quick_pay_buttons) + void llSetPayPrice(int price, LSL_Types.list quick_pay_buttons); + //wiki: vector llGetCameraPos() + LSL_Types.Vector3 llGetCameraPos(); + //wiki rotation llGetCameraRot() + LSL_Types.Quaternion llGetCameraRot(); + //wiki: (deprecated) + void llSetPrimURL(); + //wiki: (deprecated) + void llRefreshPrimURL(); + //wiki: string llEscapeURL(string url) + string llEscapeURL(string url); + //wiki: string llUnescapeURL(string url) + string llUnescapeURL(string url); + //wiki: llMapDestination(string simname, vector pos, vector look_at) + void llMapDestination(string simname, LSL_Types.Vector3 pos, LSL_Types.Vector3 look_at); + //wiki: llAddToLandBanList(key avatar, double hours) + void llAddToLandBanList(string avatar, double hours); + //wiki: llRemoveFromLandPassList(key avatar) + void llRemoveFromLandPassList(string avatar); + //wiki: llRemoveFromLandBanList(key avatar) + void llRemoveFromLandBanList(string avatar); + //wiki: llSetCameraParams(list rules) + void llSetCameraParams(LSL_Types.list rules); + //wiki: llClearCameraParams() + void llClearCameraParams(); + //wiki: double llListStatistics(integer operation, list src) + double llListStatistics(int operation, LSL_Types.list src); + //wiki: integer llGetUnixTime() + LSL_Types.LSLInteger llGetUnixTime(); + //wiki: integer llGetParcelFlags(vector pos) + LSL_Types.LSLInteger llGetParcelFlags(LSL_Types.Vector3 pos); + //wiki: integer llGetRegionFlags() + LSL_Types.LSLInteger llGetRegionFlags(); + //wiki: string llXorBase64StringsCorrect(string str1, string str2) + string llXorBase64StringsCorrect(string str1, string str2); + string llHTTPRequest(string url, LSL_Types.list parameters, string body); + //wiki: llResetLandBanList() + void llResetLandBanList(); + //wiki: llResetLandPassList() + void llResetLandPassList(); + //wiki: integer llGetParcelPrimCount(vector pos, integer category, integer sim_wide) + LSL_Types.LSLInteger llGetParcelPrimCount(LSL_Types.Vector3 pos, int category, int sim_wide); + //wiki: list llGetParcelPrimOwners(vector pos) + LSL_Types.list llGetParcelPrimOwners(LSL_Types.Vector3 pos); + //wiki: integer llGetObjectPrimCount(key object_id) + LSL_Types.LSLInteger llGetObjectPrimCount(string object_id); + //wiki: integer llGetParcelMaxPrims(vector pos, integer sim_wide) + LSL_Types.LSLInteger llGetParcelMaxPrims(LSL_Types.Vector3 pos, int sim_wide); + //wiki: llGetParcelDetails(vector pos, list params) + LSL_Types.list llGetParcelDetails(LSL_Types.Vector3 pos, LSL_Types.list param); + //wiki: llSetLinkTexture(integer linknumber, string texture, integer face) + void llSetLinkTexture(int linknumber, string texture, int face); + //wiki: string llStringTrim(string src, int type) + string llStringTrim(string src, int type); + //wiki: LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args) + LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args); + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs new file mode 100644 index 0000000..1e14c63 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs @@ -0,0 +1,68 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces +{ + public interface IOSSL_Api + { + //OpenSim functions + string osSetDynamicTextureURL(string dynamicID, string contentType, string url, string extraParams, int timer); + string osSetDynamicTextureURLBlend(string dynamicID, string contentType, string url, string extraParams, + int timer, int alpha); + string osSetDynamicTextureData(string dynamicID, string contentType, string data, string extraParams, int timer); + string osSetDynamicTextureDataBlend(string dynamicID, string contentType, string data, string extraParams, + int timer, int alpha); + double osTerrainGetHeight(int x, int y); + int osTerrainSetHeight(int x, int y, double val); + int osRegionRestart(double seconds); + void osRegionNotice(string msg); + bool osConsoleCommand(string Command); + void osSetParcelMediaURL(string url); + void osSetPrimFloatOnWater(int floatYN); + + // Animation commands + void osAvatarPlayAnimation(string avatar, string animation); + void osAvatarStopAnimation(string avatar, string animation); + + //texture draw functions + string osMovePen(string drawList, int x, int y); + string osDrawLine(string drawList, int startX, int startY, int endX, int endY); + string osDrawLine(string drawList, int endX, int endY); + string osDrawText(string drawList, string text); + string osDrawEllipse(string drawList, int width, int height); + string osDrawRectangle(string drawList, int width, int height); + string osDrawFilledRectangle(string drawList, int width, int height); + string osSetFontSize(string drawList, int fontSize); + string osSetPenSize(string drawList, int penSize); + string osSetPenColour(string drawList, string colour); + string osDrawImage(string drawList, int width, int height, string imageUrl); + void osSetStateEvents(int events); + + double osList2Double(LSL_Types.list src, int index); + void osSetRegionWaterHeight(double height); + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs new file mode 100644 index 0000000..69be69b --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs @@ -0,0 +1,421 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3; +using rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion; + +namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase +{ + public partial class ScriptBaseClass : MarshalByRefObject + { + // LSL CONSTANTS + public const int TRUE = 1; + public const int FALSE = 0; + + public const int STATUS_PHYSICS = 1; + public const int STATUS_ROTATE_X = 2; + public const int STATUS_ROTATE_Y = 4; + public const int STATUS_ROTATE_Z = 8; + public const int STATUS_PHANTOM = 16; + public const int STATUS_SANDBOX = 32; + public const int STATUS_BLOCK_GRAB = 64; + public const int STATUS_DIE_AT_EDGE = 128; + public const int STATUS_RETURN_AT_EDGE = 256; + public const int STATUS_CAST_SHADOWS = 512; + + public const int AGENT = 1; + public const int ACTIVE = 2; + public const int PASSIVE = 4; + public const int SCRIPTED = 8; + + public const int CONTROL_FWD = 1; + public const int CONTROL_BACK = 2; + public const int CONTROL_LEFT = 4; + public const int CONTROL_RIGHT = 8; + public const int CONTROL_UP = 16; + public const int CONTROL_DOWN = 32; + public const int CONTROL_ROT_LEFT = 256; + public const int CONTROL_ROT_RIGHT = 512; + public const int CONTROL_LBUTTON = 268435456; + public const int CONTROL_ML_LBUTTON = 1073741824; + + //Permissions + public const int PERMISSION_DEBIT = 2; + public const int PERMISSION_TAKE_CONTROLS = 4; + public const int PERMISSION_REMAP_CONTROLS = 8; + public const int PERMISSION_TRIGGER_ANIMATION = 16; + public const int PERMISSION_ATTACH = 32; + public const int PERMISSION_RELEASE_OWNERSHIP = 64; + public const int PERMISSION_CHANGE_LINKS = 128; + public const int PERMISSION_CHANGE_JOINTS = 256; + public const int PERMISSION_CHANGE_PERMISSIONS = 512; + public const int PERMISSION_TRACK_CAMERA = 1024; + + public const int AGENT_FLYING = 1; + public const int AGENT_ATTACHMENTS = 2; + public const int AGENT_SCRIPTED = 4; + public const int AGENT_MOUSELOOK = 8; + public const int AGENT_SITTING = 16; + public const int AGENT_ON_OBJECT = 32; + public const int AGENT_AWAY = 64; + public const int AGENT_WALKING = 128; + public const int AGENT_IN_AIR = 256; + public const int AGENT_TYPING = 512; + public const int AGENT_CROUCHING = 1024; + public const int AGENT_BUSY = 2048; + public const int AGENT_ALWAYS_RUN = 4096; + + //Particle Systems + public const int PSYS_PART_INTERP_COLOR_MASK = 1; + public const int PSYS_PART_INTERP_SCALE_MASK = 2; + public const int PSYS_PART_BOUNCE_MASK = 4; + public const int PSYS_PART_WIND_MASK = 8; + public const int PSYS_PART_FOLLOW_SRC_MASK = 16; + public const int PSYS_PART_FOLLOW_VELOCITY_MASK = 32; + public const int PSYS_PART_TARGET_POS_MASK = 64; + public const int PSYS_PART_TARGET_LINEAR_MASK = 128; + public const int PSYS_PART_EMISSIVE_MASK = 256; + public const int PSYS_PART_FLAGS = 0; + public const int PSYS_PART_START_COLOR = 1; + public const int PSYS_PART_START_ALPHA = 2; + public const int PSYS_PART_END_COLOR = 3; + public const int PSYS_PART_END_ALPHA = 4; + public const int PSYS_PART_START_SCALE = 5; + public const int PSYS_PART_END_SCALE = 6; + public const int PSYS_PART_MAX_AGE = 7; + public const int PSYS_SRC_ACCEL = 8; + public const int PSYS_SRC_PATTERN = 9; + public const int PSYS_SRC_INNERANGLE = 10; + public const int PSYS_SRC_OUTERANGLE = 11; + public const int PSYS_SRC_TEXTURE = 12; + public const int PSYS_SRC_BURST_RATE = 13; + public const int PSYS_SRC_BURST_PART_COUNT = 15; + public const int PSYS_SRC_BURST_RADIUS = 16; + public const int PSYS_SRC_BURST_SPEED_MIN = 17; + public const int PSYS_SRC_BURST_SPEED_MAX = 18; + public const int PSYS_SRC_MAX_AGE = 19; + public const int PSYS_SRC_TARGET_KEY = 20; + public const int PSYS_SRC_OMEGA = 21; + public const int PSYS_SRC_ANGLE_BEGIN = 22; + public const int PSYS_SRC_ANGLE_END = 23; + public const int PSYS_SRC_PATTERN_DROP = 1; + public const int PSYS_SRC_PATTERN_EXPLODE = 2; + public const int PSYS_SRC_PATTERN_ANGLE = 4; + public const int PSYS_SRC_PATTERN_ANGLE_CONE = 8; + public const int PSYS_SRC_PATTERN_ANGLE_CONE_EMPTY = 16; + + public const int VEHICLE_TYPE_NONE = 0; + public const int VEHICLE_TYPE_SLED = 1; + public const int VEHICLE_TYPE_CAR = 2; + public const int VEHICLE_TYPE_BOAT = 3; + public const int VEHICLE_TYPE_AIRPLANE = 4; + public const int VEHICLE_TYPE_BALLOON = 5; + public const int VEHICLE_LINEAR_FRICTION_TIMESCALE = 16; + public const int VEHICLE_ANGULAR_FRICTION_TIMESCALE = 17; + public const int VEHICLE_LINEAR_MOTOR_DIRECTION = 18; + public const int VEHICLE_LINEAR_MOTOR_OFFSET = 20; + public const int VEHICLE_ANGULAR_MOTOR_DIRECTION = 19; + public const int VEHICLE_HOVER_HEIGHT = 24; + public const int VEHICLE_HOVER_EFFICIENCY = 25; + public const int VEHICLE_HOVER_TIMESCALE = 26; + public const int VEHICLE_BUOYANCY = 27; + public const int VEHICLE_LINEAR_DEFLECTION_EFFICIENCY = 28; + public const int VEHICLE_LINEAR_DEFLECTION_TIMESCALE = 29; + public const int VEHICLE_LINEAR_MOTOR_TIMESCALE = 30; + public const int VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE = 31; + public const int VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY = 32; + public const int VEHICLE_ANGULAR_DEFLECTION_TIMESCALE = 33; + public const int VEHICLE_ANGULAR_MOTOR_TIMESCALE = 34; + public const int VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE = 35; + public const int VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY = 36; + public const int VEHICLE_VERTICAL_ATTRACTION_TIMESCALE = 37; + public const int VEHICLE_BANKING_EFFICIENCY = 38; + public const int VEHICLE_BANKING_MIX = 39; + public const int VEHICLE_BANKING_TIMESCALE = 40; + public const int VEHICLE_REFERENCE_FRAME = 44; + public const int VEHICLE_FLAG_NO_DEFLECTION_UP = 1; + public const int VEHICLE_FLAG_LIMIT_ROLL_ONLY = 2; + public const int VEHICLE_FLAG_HOVER_WATER_ONLY = 4; + public const int VEHICLE_FLAG_HOVER_TERRAIN_ONLY = 8; + public const int VEHICLE_FLAG_HOVER_GLOBAL_HEIGHT = 16; + public const int VEHICLE_FLAG_HOVER_UP_ONLY = 32; + public const int VEHICLE_FLAG_LIMIT_MOTOR_UP = 64; + public const int VEHICLE_FLAG_MOUSELOOK_STEER = 128; + public const int VEHICLE_FLAG_MOUSELOOK_BANK = 256; + public const int VEHICLE_FLAG_CAMERA_DECOUPLED = 512; + + public const int INVENTORY_ALL = -1; + public const int INVENTORY_NONE = -1; + public const int INVENTORY_TEXTURE = 0; + public const int INVENTORY_SOUND = 1; + public const int INVENTORY_LANDMARK = 3; + public const int INVENTORY_CLOTHING = 5; + public const int INVENTORY_OBJECT = 6; + public const int INVENTORY_NOTECARD = 7; + public const int INVENTORY_SCRIPT = 10; + public const int INVENTORY_BODYPART = 13; + public const int INVENTORY_ANIMATION = 20; + public const int INVENTORY_GESTURE = 21; + + public const int ATTACH_CHEST = 1; + public const int ATTACH_HEAD = 2; + public const int ATTACH_LSHOULDER = 3; + public const int ATTACH_RSHOULDER = 4; + public const int ATTACH_LHAND = 5; + public const int ATTACH_RHAND = 6; + public const int ATTACH_LFOOT = 7; + public const int ATTACH_RFOOT = 8; + public const int ATTACH_BACK = 9; + public const int ATTACH_PELVIS = 10; + public const int ATTACH_MOUTH = 11; + public const int ATTACH_CHIN = 12; + public const int ATTACH_LEAR = 13; + public const int ATTACH_REAR = 14; + public const int ATTACH_LEYE = 15; + public const int ATTACH_REYE = 16; + public const int ATTACH_NOSE = 17; + public const int ATTACH_RUARM = 18; + public const int ATTACH_RLARM = 19; + public const int ATTACH_LUARM = 20; + public const int ATTACH_LLARM = 21; + public const int ATTACH_RHIP = 22; + public const int ATTACH_RULEG = 23; + public const int ATTACH_RLLEG = 24; + public const int ATTACH_LHIP = 25; + public const int ATTACH_LULEG = 26; + public const int ATTACH_LLLEG = 27; + public const int ATTACH_BELLY = 28; + public const int ATTACH_RPEC = 29; + public const int ATTACH_LPEC = 30; + + public const int LAND_LEVEL = 0; + public const int LAND_RAISE = 1; + public const int LAND_LOWER = 2; + public const int LAND_SMOOTH = 3; + public const int LAND_NOISE = 4; + public const int LAND_REVERT = 5; + public const int LAND_SMALL_BRUSH = 1; + public const int LAND_MEDIUM_BRUSH = 2; + public const int LAND_LARGE_BRUSH = 3; + + //Agent Dataserver + public const int DATA_ONLINE = 1; + public const int DATA_NAME = 2; + public const int DATA_BORN = 3; + public const int DATA_RATING = 4; + public const int DATA_SIM_POS = 5; + public const int DATA_SIM_STATUS = 6; + public const int DATA_SIM_RATING = 7; + public const int DATA_PAYINFO = 8; + + public const int ANIM_ON = 1; + public const int LOOP = 2; + public const int REVERSE = 4; + public const int PING_PONG = 8; + public const int SMOOTH = 16; + public const int ROTATE = 32; + public const int SCALE = 64; + public const int ALL_SIDES = -1; + public const int LINK_SET = -1; + public const int LINK_ROOT = 1; + public const int LINK_ALL_OTHERS = -2; + public const int LINK_ALL_CHILDREN = -3; + public const int LINK_THIS = -4; + public const int CHANGED_INVENTORY = 1; + public const int CHANGED_COLOR = 2; + public const int CHANGED_SHAPE = 4; + public const int CHANGED_SCALE = 8; + public const int CHANGED_TEXTURE = 16; + public const int CHANGED_LINK = 32; + public const int CHANGED_ALLOWED_DROP = 64; + public const int CHANGED_OWNER = 128; + public const int CHANGED_REGION_RESTART = 256; + public const int TYPE_INVALID = 0; + public const int TYPE_INTEGER = 1; + public const int TYPE_double = 2; + public const int TYPE_STRING = 3; + public const int TYPE_KEY = 4; + public const int TYPE_VECTOR = 5; + public const int TYPE_ROTATION = 6; + + //XML RPC Remote Data Channel + public const int REMOTE_DATA_CHANNEL = 1; + public const int REMOTE_DATA_REQUEST = 2; + public const int REMOTE_DATA_REPLY = 3; + + //llHTTPRequest + public const int HTTP_METHOD = 0; + public const int HTTP_MIMETYPE = 1; + public const int HTTP_BODY_MAXLENGTH = 2; + public const int HTTP_VERIFY_CERT = 3; + + public const int PRIM_MATERIAL = 2; + public const int PRIM_PHYSICS = 3; + public const int PRIM_TEMP_ON_REZ = 4; + public const int PRIM_PHANTOM = 5; + public const int PRIM_POSITION = 6; + public const int PRIM_SIZE = 7; + public const int PRIM_ROTATION = 8; + public const int PRIM_TYPE = 9; + public const int PRIM_TEXTURE = 17; + public const int PRIM_COLOR = 18; + public const int PRIM_BUMP_SHINY = 19; + public const int PRIM_FULLBRIGHT = 20; + public const int PRIM_FLEXIBLE = 21; + public const int PRIM_TEXGEN = 22; + public const int PRIM_CAST_SHADOWS = 24; // Not implemented, here for completeness sake + public const int PRIM_POINT_LIGHT = 23; // Huh? + public const int PRIM_TEXGEN_DEFAULT = 0; + public const int PRIM_TEXGEN_PLANAR = 1; + + public const int PRIM_TYPE_BOX = 0; + public const int PRIM_TYPE_CYLINDER = 1; + public const int PRIM_TYPE_PRISM = 2; + public const int PRIM_TYPE_SPHERE = 3; + public const int PRIM_TYPE_TORUS = 4; + public const int PRIM_TYPE_TUBE = 5; + public const int PRIM_TYPE_RING = 6; + public const int PRIM_TYPE_SCULPT = 7; + + public const int PRIM_HOLE_DEFAULT = 0; + public const int PRIM_HOLE_CIRCLE = 16; + public const int PRIM_HOLE_SQUARE = 32; + public const int PRIM_HOLE_TRIANGLE = 48; + + public const int PRIM_MATERIAL_STONE = 0; + public const int PRIM_MATERIAL_METAL = 1; + public const int PRIM_MATERIAL_GLASS = 2; + public const int PRIM_MATERIAL_WOOD = 3; + public const int PRIM_MATERIAL_FLESH = 4; + public const int PRIM_MATERIAL_PLASTIC = 5; + public const int PRIM_MATERIAL_RUBBER = 6; + public const int PRIM_MATERIAL_LIGHT = 7; + + public const int PRIM_SHINY_NONE = 0; + public const int PRIM_SHINY_LOW = 1; + public const int PRIM_SHINY_MEDIUM = 2; + public const int PRIM_SHINY_HIGH = 3; + public const int PRIM_BUMP_NONE = 0; + public const int PRIM_BUMP_BRIGHT = 1; + public const int PRIM_BUMP_DARK = 2; + public const int PRIM_BUMP_WOOD = 3; + public const int PRIM_BUMP_BARK = 4; + public const int PRIM_BUMP_BRICKS = 5; + public const int PRIM_BUMP_CHECKER = 6; + public const int PRIM_BUMP_CONCRETE = 7; + public const int PRIM_BUMP_TILE = 8; + public const int PRIM_BUMP_STONE = 9; + public const int PRIM_BUMP_DISKS = 10; + public const int PRIM_BUMP_GRAVEL = 11; + public const int PRIM_BUMP_BLOBS = 12; + public const int PRIM_BUMP_SIDING = 13; + public const int PRIM_BUMP_LARGETILE = 14; + public const int PRIM_BUMP_STUCCO = 15; + public const int PRIM_BUMP_SUCTION = 16; + public const int PRIM_BUMP_WEAVE = 17; + + public const int PRIM_SCULPT_TYPE_SPHERE = 1; + public const int PRIM_SCULPT_TYPE_TORUS = 2; + public const int PRIM_SCULPT_TYPE_PLANE = 3; + public const int PRIM_SCULPT_TYPE_CYLINDER = 4; + + public const int MASK_BASE = 0; + public const int MASK_OWNER = 1; + public const int MASK_GROUP = 2; + public const int MASK_EVERYONE = 3; + public const int MASK_NEXT = 4; + + public const int PERM_TRANSFER = 8192; + public const int PERM_MODIFY = 16384; + public const int PERM_COPY = 32768; + public const int PERM_MOVE = 524288; + public const int PERM_ALL = 2147483647; + + public const int PARCEL_MEDIA_COMMAND_STOP = 0; + public const int PARCEL_MEDIA_COMMAND_PAUSE = 1; + public const int PARCEL_MEDIA_COMMAND_PLAY = 2; + public const int PARCEL_MEDIA_COMMAND_LOOP = 3; + public const int PARCEL_MEDIA_COMMAND_TEXTURE = 4; + public const int PARCEL_MEDIA_COMMAND_URL = 5; + public const int PARCEL_MEDIA_COMMAND_TIME = 6; + public const int PARCEL_MEDIA_COMMAND_AGENT = 7; + public const int PARCEL_MEDIA_COMMAND_UNLOAD = 8; + public const int PARCEL_MEDIA_COMMAND_AUTO_ALIGN = 9; + + public const int PAY_HIDE = -1; + public const int PAY_DEFAULT = -2; + + public const string NULL_KEY = "00000000-0000-0000-0000-000000000000"; + public const string EOF = "\n\n\n"; + public const double PI = 3.14159274f; + public const double TWO_PI = 6.28318548f; + public const double PI_BY_TWO = 1.57079637f; + public const double DEG_TO_RAD = 0.01745329238f; + public const double RAD_TO_DEG = 57.29578f; + public const double SQRT2 = 1.414213538f; + public const int STRING_TRIM_HEAD = 1; + public const int STRING_TRIM_TAIL = 2; + public const int STRING_TRIM = 3; + public const int LIST_STAT_RANGE = 0; + public const int LIST_STAT_MIN = 1; + public const int LIST_STAT_MAX = 2; + public const int LIST_STAT_MEAN = 3; + public const int LIST_STAT_MEDIAN = 4; + public const int LIST_STAT_STD_DEV = 5; + public const int LIST_STAT_SUM = 6; + public const int LIST_STAT_SUM_SQUARES = 7; + public const int LIST_STAT_NUM_COUNT = 8; + public const int LIST_STAT_GEOMETRIC_MEAN = 9; + public const int LIST_STAT_HARMONIC_MEAN = 100; + + //ParcelPrim Categories + public const int PARCEL_COUNT_TOTAL = 0; + public const int PARCEL_COUNT_OWNER = 1; + public const int PARCEL_COUNT_GROUP = 2; + public const int PARCEL_COUNT_OTHER = 3; + public const int PARCEL_COUNT_SELECTED = 4; + public const int PARCEL_COUNT_TEMP = 5; + + public const int DEBUG_CHANNEL = 0x7FFFFFFF; + public const int PUBLIC_CHANNEL = 0x00000000; + + public const int OBJECT_NAME = 1; + public const int OBJECT_DESC = 2; + public const int OBJECT_POS = 3; + public const int OBJECT_ROT = 4; + public const int OBJECT_VELOCITY = 5; + public const int OBJECT_OWNER = 6; + public const int OBJECT_GROUP = 7; + public const int OBJECT_CREATOR = 8; + + // Can not be public const? + public vector ZERO_VECTOR = new vector(0.0, 0.0, 0.0); + public rotation ZERO_ROTATION = new rotation(0.0, 0, 0.0, 1.0); + + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs new file mode 100644 index 0000000..7b3907f --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs @@ -0,0 +1,1732 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Runtime.Remoting.Lifetime; +using System.Threading; +using System.Reflection; +using System.Collections; +using System.Collections.Generic; +using OpenSim.Region.ScriptEngine.Interfaces; +using OpenSim.Region.ScriptEngine.Shared.Api.Interfaces; +using integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger; +using key = System.String; +using vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3; +using rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion; + +namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase +{ + public partial class ScriptBaseClass : MarshalByRefObject + { + public ILSL_Api m_LSL_Functions; + + public void ApiTypeLSL(IScriptApi api) + { + if(!(api is ILSL_Api)) + return; + + m_LSL_Functions = (ILSL_Api)api; + } + + public void state(string newState) + { + m_LSL_Functions.state(newState); + } + + // + // Script functions + // + public void llSay(int channelID, string text) + { + m_LSL_Functions.llSay(channelID, text); + } + + public double llSin(double f) + { + return m_LSL_Functions.llSin(f); + } + + public double llCos(double f) + { + return m_LSL_Functions.llCos(f); + } + + public double llTan(double f) + { + return m_LSL_Functions.llTan(f); + } + + public double llAtan2(double x, double y) + { + return m_LSL_Functions.llAtan2(x, y); + } + + public double llSqrt(double f) + { + return m_LSL_Functions.llSqrt(f); + } + + public double llPow(double fbase, double fexponent) + { + return m_LSL_Functions.llPow(fbase, fexponent); + } + + public LSL_Types.LSLInteger llAbs(int i) + { + return m_LSL_Functions.llAbs(i); + } + + public double llFabs(double f) + { + return m_LSL_Functions.llFabs(f); + } + + public double llFrand(double mag) + { + return m_LSL_Functions.llFrand(mag); + } + + public LSL_Types.LSLInteger llFloor(double f) + { + return m_LSL_Functions.llFloor(f); + } + + public LSL_Types.LSLInteger llCeil(double f) + { + return m_LSL_Functions.llCeil(f); + } + + public LSL_Types.LSLInteger llRound(double f) + { + return m_LSL_Functions.llRound(f); + } + + public double llVecMag(vector v) + { + return m_LSL_Functions.llVecMag(v); + } + + public vector llVecNorm(vector v) + { + return m_LSL_Functions.llVecNorm(v); + } + + public double llVecDist(vector a, vector b) + { + return m_LSL_Functions.llVecDist(a, b); + } + + public vector llRot2Euler(rotation r) + { + return m_LSL_Functions.llRot2Euler(r); + } + + public rotation llEuler2Rot(vector v) + { + return m_LSL_Functions.llEuler2Rot(v); + } + + public rotation llAxes2Rot(vector fwd, vector left, vector up) + { + return m_LSL_Functions.llAxes2Rot(fwd, left, up); + } + + public vector llRot2Fwd(rotation r) + { + return m_LSL_Functions.llRot2Fwd(r); + } + + public vector llRot2Left(rotation r) + { + return m_LSL_Functions.llRot2Left(r); + } + + public vector llRot2Up(rotation r) + { + return m_LSL_Functions.llRot2Up(r); + } + + public rotation llRotBetween(vector start, vector end) + { + return m_LSL_Functions.llRotBetween(start, end); + } + + public void llWhisper(int channelID, string text) + { + m_LSL_Functions.llWhisper(channelID, text); + } + + public void llShout(int channelID, string text) + { + m_LSL_Functions.llShout(channelID, text); + } + + public void llRegionSay(int channelID, string text) + { + m_LSL_Functions.llRegionSay(channelID, text); + } + + public LSL_Types.LSLInteger llListen(int channelID, string name, string ID, string msg) + { + return m_LSL_Functions.llListen(channelID, name, ID, msg); + } + + public void llListenControl(int number, int active) + { + m_LSL_Functions.llListenControl(number, active); + } + + public void llListenRemove(int number) + { + m_LSL_Functions.llListenRemove(number); + } + + public void llSensor(string name, string id, int type, double range, double arc) + { + m_LSL_Functions.llSensor(name, id, type, range, arc); + } + + public void llSensorRepeat(string name, string id, int type, double range, double arc, double rate) + { + m_LSL_Functions.llSensorRepeat(name, id, type, range, arc, rate); + } + + public void llSensorRemove() + { + m_LSL_Functions.llSensorRemove(); + } + + public string llDetectedName(int number) + { + return m_LSL_Functions.llDetectedName(number); + } + + public string llDetectedKey(int number) + { + return m_LSL_Functions.llDetectedKey(number); + } + + public string llDetectedOwner(int number) + { + return m_LSL_Functions.llDetectedOwner(number); + } + + public LSL_Types.LSLInteger llDetectedType(int number) + { + return m_LSL_Functions.llDetectedType(number); + } + + public vector llDetectedPos(int number) + { + return m_LSL_Functions.llDetectedPos(number); + } + + public vector llDetectedVel(int number) + { + return m_LSL_Functions.llDetectedVel(number); + } + + public vector llDetectedGrab(int number) + { + return m_LSL_Functions.llDetectedGrab(number); + } + + public rotation llDetectedRot(int number) + { + return m_LSL_Functions.llDetectedRot(number); + } + + public LSL_Types.LSLInteger llDetectedGroup(int number) + { + return m_LSL_Functions.llDetectedGroup(number); + } + + public LSL_Types.LSLInteger llDetectedLinkNumber(int number) + { + return m_LSL_Functions.llDetectedLinkNumber(number); + } + + public void llDie() + { + m_LSL_Functions.llDie(); + } + + public double llGround(vector offset) + { + return m_LSL_Functions.llGround(offset); + } + + public double llCloud(vector offset) + { + return m_LSL_Functions.llCloud(offset); + } + + public vector llWind(vector offset) + { + return m_LSL_Functions.llWind(offset); + } + + public void llSetStatus(int status, int value) + { + m_LSL_Functions.llSetStatus(status, value); + } + + public LSL_Types.LSLInteger llGetStatus(int status) + { + return m_LSL_Functions.llGetStatus(status); + } + + public void llSetScale(vector scale) + { + m_LSL_Functions.llSetScale(scale); + } + + public vector llGetScale() + { + return m_LSL_Functions.llGetScale(); + } + + public void llSetColor(vector color, int face) + { + m_LSL_Functions.llSetColor(color, face); + } + + public double llGetAlpha(int face) + { + return m_LSL_Functions.llGetAlpha(face); + } + + public void llSetAlpha(double alpha, int face) + { + m_LSL_Functions.llSetAlpha(alpha, face); + } + + public vector llGetColor(int face) + { + return m_LSL_Functions.llGetColor(face); + } + + public void llSetTexture(string texture, int face) + { + m_LSL_Functions.llSetTexture(texture, face); + } + + public void llScaleTexture(double u, double v, int face) + { + m_LSL_Functions.llScaleTexture(u, v, face); + } + + public void llOffsetTexture(double u, double v, int face) + { + m_LSL_Functions.llOffsetTexture(u, v, face); + } + + public void llRotateTexture(double rotation, int face) + { + m_LSL_Functions.llRotateTexture(rotation, face); + } + + public string llGetTexture(int face) + { + return m_LSL_Functions.llGetTexture(face); + } + + public void llSetPos(vector pos) + { + m_LSL_Functions.llSetPos(pos); + } + + public vector llGetPos() + { + return m_LSL_Functions.llGetPos(); + } + + public vector llGetLocalPos() + { + return m_LSL_Functions.llGetLocalPos(); + } + + public void llSetRot(rotation rot) + { + m_LSL_Functions.llSetRot(rot); + } + + public rotation llGetRot() + { + return m_LSL_Functions.llGetRot(); + } + + public rotation llGetLocalRot() + { + return m_LSL_Functions.llGetLocalRot(); + } + + public void llSetForce(vector force, int local) + { + m_LSL_Functions.llSetForce(force, local); + } + + public vector llGetForce() + { + return m_LSL_Functions.llGetForce(); + } + + public LSL_Types.LSLInteger llTarget(vector position, double range) + { + return m_LSL_Functions.llTarget(position, range); + } + + public void llTargetRemove(int number) + { + m_LSL_Functions.llTargetRemove(number); + } + + public LSL_Types.LSLInteger llRotTarget(rotation rot, double error) + { + return m_LSL_Functions.llRotTarget(rot, error); + } + + public void llRotTargetRemove(int number) + { + m_LSL_Functions.llRotTargetRemove(number); + } + + public void llMoveToTarget(vector target, double tau) + { + m_LSL_Functions.llMoveToTarget(target, tau); + } + + public void llStopMoveToTarget() + { + m_LSL_Functions.llStopMoveToTarget(); + } + + public void llApplyImpulse(vector force, int local) + { + m_LSL_Functions.llApplyImpulse(force, local); + } + + public void llApplyRotationalImpulse(vector force, int local) + { + m_LSL_Functions.llApplyRotationalImpulse(force, local); + } + + public void llSetTorque(vector torque, int local) + { + m_LSL_Functions.llSetTorque(torque, local); + } + + public vector llGetTorque() + { + return m_LSL_Functions.llGetTorque(); + } + + public void llSetForceAndTorque(vector force, vector torque, int local) + { + m_LSL_Functions.llSetForceAndTorque(force, torque, local); + } + + public vector llGetVel() + { + return m_LSL_Functions.llGetVel(); + } + + public vector llGetAccel() + { + return m_LSL_Functions.llGetAccel(); + } + + public vector llGetOmega() + { + return m_LSL_Functions.llGetOmega(); + } + + public double llGetTimeOfDay() + { + return m_LSL_Functions.llGetTimeOfDay(); + } + + public double llGetWallclock() + { + return m_LSL_Functions.llGetWallclock(); + } + + public double llGetTime() + { + return m_LSL_Functions.llGetTime(); + } + + public void llResetTime() + { + m_LSL_Functions.llResetTime(); + } + + public double llGetAndResetTime() + { + return m_LSL_Functions.llGetAndResetTime(); + } + + public void llSound() + { + m_LSL_Functions.llSound(); + } + + public void llPlaySound(string sound, double volume) + { + m_LSL_Functions.llPlaySound(sound, volume); + } + + public void llLoopSound(string sound, double volume) + { + m_LSL_Functions.llLoopSound(sound, volume); + } + + public void llLoopSoundMaster(string sound, double volume) + { + m_LSL_Functions.llLoopSoundMaster(sound, volume); + } + + public void llLoopSoundSlave(string sound, double volume) + { + m_LSL_Functions.llLoopSoundSlave(sound, volume); + } + + public void llPlaySoundSlave(string sound, double volume) + { + m_LSL_Functions.llPlaySoundSlave(sound, volume); + } + + public void llTriggerSound(string sound, double volume) + { + m_LSL_Functions.llTriggerSound(sound, volume); + } + + public void llStopSound() + { + m_LSL_Functions.llStopSound(); + } + + public void llPreloadSound(string sound) + { + m_LSL_Functions.llPreloadSound(sound); + } + + public string llGetSubString(string src, int start, int end) + { + return m_LSL_Functions.llGetSubString(src, start, end); + } + + public string llDeleteSubString(string src, int start, int end) + { + return m_LSL_Functions.llDeleteSubString(src, start, end); + } + + public string llInsertString(string dst, int position, string src) + { + return m_LSL_Functions.llInsertString(dst, position, src); + } + + public string llToUpper(string source) + { + return m_LSL_Functions.llToUpper(source); + } + + public string llToLower(string source) + { + return m_LSL_Functions.llToLower(source); + } + + public LSL_Types.LSLInteger llGiveMoney(string destination, int amount) + { + return m_LSL_Functions.llGiveMoney(destination, amount); + } + + public void llMakeExplosion() + { + m_LSL_Functions.llMakeExplosion(); + } + + public void llMakeFountain() + { + m_LSL_Functions.llMakeFountain(); + } + + public void llMakeSmoke() + { + m_LSL_Functions.llMakeSmoke(); + } + + public void llMakeFire() + { + m_LSL_Functions.llMakeFire(); + } + + public void llRezObject(string inventory, vector pos, vector vel, rotation rot, int param) + { + m_LSL_Functions.llRezObject(inventory, pos, vel, rot, param); + } + + public void llLookAt(vector target, double strength, double damping) + { + m_LSL_Functions.llLookAt(target, strength, damping); + } + + public void llStopLookAt() + { + m_LSL_Functions.llStopLookAt(); + } + + public void llSetTimerEvent(double sec) + { + m_LSL_Functions.llSetTimerEvent(sec); + } + + public void llSleep(double sec) + { + m_LSL_Functions.llSleep(sec); + } + + public double llGetMass() + { + return m_LSL_Functions.llGetMass(); + } + + public void llCollisionFilter(string name, string id, int accept) + { + m_LSL_Functions.llCollisionFilter(name, id, accept); + } + + public void llTakeControls(int controls, int accept, int pass_on) + { + m_LSL_Functions.llTakeControls(controls, accept, pass_on); + } + + public void llReleaseControls() + { + m_LSL_Functions.llReleaseControls(); + } + + public void llAttachToAvatar(int attachment) + { + m_LSL_Functions.llAttachToAvatar(attachment); + } + + public void llDetachFromAvatar() + { + m_LSL_Functions.llDetachFromAvatar(); + } + + public void llTakeCamera() + { + m_LSL_Functions.llTakeCamera(); + } + + public void llReleaseCamera() + { + m_LSL_Functions.llReleaseCamera(); + } + + public string llGetOwner() + { + return m_LSL_Functions.llGetOwner(); + } + + public void llInstantMessage(string user, string message) + { + m_LSL_Functions.llInstantMessage(user, message); + } + + public void llEmail(string address, string subject, string message) + { + m_LSL_Functions.llEmail(address, subject, message); + } + + public void llGetNextEmail(string address, string subject) + { + m_LSL_Functions.llGetNextEmail(address, subject); + } + + public string llGetKey() + { + return m_LSL_Functions.llGetKey(); + } + + public void llSetBuoyancy(double buoyancy) + { + m_LSL_Functions.llSetBuoyancy(buoyancy); + } + + public void llSetHoverHeight(double height, int water, double tau) + { + m_LSL_Functions.llSetHoverHeight(height, water, tau); + } + + public void llStopHover() + { + m_LSL_Functions.llStopHover(); + } + + public void llMinEventDelay(double delay) + { + m_LSL_Functions.llMinEventDelay(delay); + } + + public void llSoundPreload() + { + m_LSL_Functions.llSoundPreload(); + } + + public void llRotLookAt(rotation target, double strength, double damping) + { + m_LSL_Functions.llRotLookAt(target, strength, damping); + } + + public LSL_Types.LSLInteger llStringLength(string str) + { + return m_LSL_Functions.llStringLength(str); + } + + public void llStartAnimation(string anim) + { + m_LSL_Functions.llStartAnimation(anim); + } + + public void llStopAnimation(string anim) + { + m_LSL_Functions.llStopAnimation(anim); + } + + public void llPointAt() + { + m_LSL_Functions.llPointAt(); + } + + public void llStopPointAt() + { + m_LSL_Functions.llStopPointAt(); + } + + public void llTargetOmega(vector axis, double spinrate, double gain) + { + m_LSL_Functions.llTargetOmega(axis, spinrate, gain); + } + + public LSL_Types.LSLInteger llGetStartParameter() + { + return m_LSL_Functions.llGetStartParameter(); + } + + public void llGodLikeRezObject(string inventory, vector pos) + { + m_LSL_Functions.llGodLikeRezObject(inventory, pos); + } + + public void llRequestPermissions(string agent, int perm) + { + m_LSL_Functions.llRequestPermissions(agent, perm); + } + + public string llGetPermissionsKey() + { + return m_LSL_Functions.llGetPermissionsKey(); + } + + public LSL_Types.LSLInteger llGetPermissions() + { + return m_LSL_Functions.llGetPermissions(); + } + + public LSL_Types.LSLInteger llGetLinkNumber() + { + return m_LSL_Functions.llGetLinkNumber(); + } + + public void llSetLinkColor(int linknumber, vector color, int face) + { + m_LSL_Functions.llSetLinkColor(linknumber, color, face); + } + + public void llCreateLink(string target, int parent) + { + m_LSL_Functions.llCreateLink(target, parent); + } + + public void llBreakLink(int linknum) + { + m_LSL_Functions.llBreakLink(linknum); + } + + public void llBreakAllLinks() + { + m_LSL_Functions.llBreakAllLinks(); + } + + public string llGetLinkKey(int linknum) + { + return m_LSL_Functions.llGetLinkKey(linknum); + } + + public string llGetLinkName(int linknum) + { + return m_LSL_Functions.llGetLinkName(linknum); + } + + public LSL_Types.LSLInteger llGetInventoryNumber(int type) + { + return m_LSL_Functions.llGetInventoryNumber(type); + } + + public string llGetInventoryName(int type, int number) + { + return m_LSL_Functions.llGetInventoryName(type, number); + } + + public void llSetScriptState(string name, int run) + { + m_LSL_Functions.llSetScriptState(name, run); + } + + public double llGetEnergy() + { + return m_LSL_Functions.llGetEnergy(); + } + + public void llGiveInventory(string destination, string inventory) + { + m_LSL_Functions.llGiveInventory(destination, inventory); + } + + public void llRemoveInventory(string item) + { + m_LSL_Functions.llRemoveInventory(item); + } + + public void llSetText(string text, vector color, double alpha) + { + m_LSL_Functions.llSetText(text, color, alpha); + } + + public double llWater(vector offset) + { + return m_LSL_Functions.llWater(offset); + } + + public void llPassTouches(int pass) + { + m_LSL_Functions.llPassTouches(pass); + } + + public string llRequestAgentData(string id, int data) + { + return m_LSL_Functions.llRequestAgentData(id, data); + } + + public string llRequestInventoryData(string name) + { + return m_LSL_Functions.llRequestInventoryData(name); + } + + public void llSetDamage(double damage) + { + m_LSL_Functions.llSetDamage(damage); + } + + public void llTeleportAgentHome(string agent) + { + m_LSL_Functions.llTeleportAgentHome(agent); + } + + public void llModifyLand(int action, int brush) + { + m_LSL_Functions.llModifyLand(action, brush); + } + + public void llCollisionSound(string impact_sound, double impact_volume) + { + m_LSL_Functions.llCollisionSound(impact_sound, impact_volume); + } + + public void llCollisionSprite(string impact_sprite) + { + m_LSL_Functions.llCollisionSprite(impact_sprite); + } + + public string llGetAnimation(string id) + { + return m_LSL_Functions.llGetAnimation(id); + } + + public void llResetScript() + { + m_LSL_Functions.llResetScript(); + } + + public void llMessageLinked(int linknum, int num, string str, string id) + { + m_LSL_Functions.llMessageLinked(linknum, num, str, id); + } + + public void llPushObject(string target, vector impulse, vector ang_impulse, int local) + { + m_LSL_Functions.llPushObject(target, impulse, ang_impulse, local); + } + + public void llPassCollisions(int pass) + { + m_LSL_Functions.llPassCollisions(pass); + } + + public string llGetScriptName() + { + return m_LSL_Functions.llGetScriptName(); + } + + public LSL_Types.LSLInteger llGetNumberOfSides() + { + return m_LSL_Functions.llGetNumberOfSides(); + } + + public rotation llAxisAngle2Rot(vector axis, double angle) + { + return m_LSL_Functions.llAxisAngle2Rot(axis, angle); + } + + public vector llRot2Axis(rotation rot) + { + return m_LSL_Functions.llRot2Axis(rot); + } + + public double llRot2Angle(rotation rot) + { + return m_LSL_Functions.llRot2Angle(rot); + } + + public double llAcos(double val) + { + return m_LSL_Functions.llAcos(val); + } + + public double llAsin(double val) + { + return m_LSL_Functions.llAsin(val); + } + + public double llAngleBetween(rotation a, rotation b) + { + return m_LSL_Functions.llAngleBetween(a, b); + } + + public string llGetInventoryKey(string name) + { + return m_LSL_Functions.llGetInventoryKey(name); + } + + public void llAllowInventoryDrop(int add) + { + m_LSL_Functions.llAllowInventoryDrop(add); + } + + public vector llGetSunDirection() + { + return m_LSL_Functions.llGetSunDirection(); + } + + public vector llGetTextureOffset(int face) + { + return m_LSL_Functions.llGetTextureOffset(face); + } + + public vector llGetTextureScale(int side) + { + return m_LSL_Functions.llGetTextureScale(side); + } + + public double llGetTextureRot(int side) + { + return m_LSL_Functions.llGetTextureRot(side); + } + + public LSL_Types.LSLInteger llSubStringIndex(string source, string pattern) + { + return m_LSL_Functions.llSubStringIndex(source, pattern); + } + + public string llGetOwnerKey(string id) + { + return m_LSL_Functions.llGetOwnerKey(id); + } + + public vector llGetCenterOfMass() + { + return m_LSL_Functions.llGetCenterOfMass(); + } + + public LSL_Types.list llListSort(LSL_Types.list src, int stride, int ascending) + { + return m_LSL_Functions.llListSort(src, stride, ascending); + } + + public LSL_Types.LSLInteger llGetListLength(LSL_Types.list src) + { + return m_LSL_Functions.llGetListLength(src); + } + + public LSL_Types.LSLInteger llList2Integer(LSL_Types.list src, int index) + { + return m_LSL_Functions.llList2Integer(src, index); + } + + public string llList2String(LSL_Types.list src, int index) + { + return m_LSL_Functions.llList2String(src, index); + } + + public string llList2Key(LSL_Types.list src, int index) + { + return m_LSL_Functions.llList2Key(src, index); + } + + public vector llList2Vector(LSL_Types.list src, int index) + { + return m_LSL_Functions.llList2Vector(src, index); + } + + public rotation llList2Rot(LSL_Types.list src, int index) + { + return m_LSL_Functions.llList2Rot(src, index); + } + + public LSL_Types.list llList2List(LSL_Types.list src, int start, int end) + { + return m_LSL_Functions.llList2List(src, start, end); + } + + public LSL_Types.list llDeleteSubList(LSL_Types.list src, int start, int end) + { + return m_LSL_Functions.llDeleteSubList(src, start, end); + } + + public LSL_Types.LSLInteger llGetListEntryType(LSL_Types.list src, int index) + { + return m_LSL_Functions.llGetListEntryType(src, index); + } + + public string llList2CSV(LSL_Types.list src) + { + return m_LSL_Functions.llList2CSV(src); + } + + public LSL_Types.list llCSV2List(string src) + { + return m_LSL_Functions.llCSV2List(src); + } + + public LSL_Types.list llListRandomize(LSL_Types.list src, int stride) + { + return m_LSL_Functions.llListRandomize(src, stride); + } + + public LSL_Types.list llList2ListStrided(LSL_Types.list src, int start, int end, int stride) + { + return m_LSL_Functions.llList2ListStrided(src, start, end, stride); + } + + public vector llGetRegionCorner() + { + return m_LSL_Functions.llGetRegionCorner(); + } + + public LSL_Types.list llListInsertList(LSL_Types.list dest, LSL_Types.list src, int start) + { + return m_LSL_Functions.llListInsertList(dest, src, start); + } + + public LSL_Types.LSLInteger llListFindList(LSL_Types.list src, LSL_Types.list test) + { + return m_LSL_Functions.llListFindList(src, test); + } + + public string llGetObjectName() + { + return m_LSL_Functions.llGetObjectName(); + } + + public void llSetObjectName(string name) + { + m_LSL_Functions.llSetObjectName(name); + } + + public string llGetDate() + { + return m_LSL_Functions.llGetDate(); + } + + public LSL_Types.LSLInteger llEdgeOfWorld(vector pos, vector dir) + { + return m_LSL_Functions.llEdgeOfWorld(pos, dir); + } + + public LSL_Types.LSLInteger llGetAgentInfo(string id) + { + return m_LSL_Functions.llGetAgentInfo(id); + } + + public void llAdjustSoundVolume(double volume) + { + m_LSL_Functions.llAdjustSoundVolume(volume); + } + + public void llSetSoundQueueing(int queue) + { + m_LSL_Functions.llSetSoundQueueing(queue); + } + + public void llSetSoundRadius(double radius) + { + m_LSL_Functions.llSetSoundRadius(radius); + } + + public string llKey2Name(string id) + { + return m_LSL_Functions.llKey2Name(id); + } + + public void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate) + { + m_LSL_Functions.llSetTextureAnim(mode, face, sizex, sizey, start, length, rate); + } + + public void llTriggerSoundLimited(string sound, double volume, vector top_north_east, vector bottom_south_west) + { + m_LSL_Functions.llTriggerSoundLimited(sound, volume, top_north_east, bottom_south_west); + } + + public void llEjectFromLand(string pest) + { + m_LSL_Functions.llEjectFromLand(pest); + } + + public LSL_Types.list llParseString2List(string str, LSL_Types.list separators, LSL_Types.list spacers) + { + return m_LSL_Functions.llParseString2List(str,separators,spacers); + } + + public LSL_Types.LSLInteger llOverMyLand(string id) + { + return m_LSL_Functions.llOverMyLand(id); + } + + public string llGetLandOwnerAt(vector pos) + { + return m_LSL_Functions.llGetLandOwnerAt(pos); + } + + public string llGetNotecardLine(string name, int line) + { + return m_LSL_Functions.llGetNotecardLine(name, line); + } + + public vector llGetAgentSize(string id) + { + return m_LSL_Functions.llGetAgentSize(id); + } + + public LSL_Types.LSLInteger llSameGroup(string agent) + { + return m_LSL_Functions.llSameGroup(agent); + } + + public void llUnSit(string id) + { + m_LSL_Functions.llUnSit(id); + } + + public vector llGroundSlope(vector offset) + { + return m_LSL_Functions.llGroundSlope(offset); + } + + public vector llGroundNormal(vector offset) + { + return m_LSL_Functions.llGroundNormal(offset); + } + + public vector llGroundContour(vector offset) + { + return m_LSL_Functions.llGroundContour(offset); + } + + public LSL_Types.LSLInteger llGetAttached() + { + return m_LSL_Functions.llGetAttached(); + } + + public LSL_Types.LSLInteger llGetFreeMemory() + { + return m_LSL_Functions.llGetFreeMemory(); + } + + public string llGetRegionName() + { + return m_LSL_Functions.llGetRegionName(); + } + + public double llGetRegionTimeDilation() + { + return m_LSL_Functions.llGetRegionTimeDilation(); + } + + public double llGetRegionFPS() + { + return m_LSL_Functions.llGetRegionFPS(); + } + + public void llParticleSystem(LSL_Types.list rules) + { + m_LSL_Functions.llParticleSystem(rules); + } + + public void llGroundRepel(double height, int water, double tau) + { + m_LSL_Functions.llGroundRepel(height, water, tau); + } + + public void llGiveInventoryList(string destination, string category, LSL_Types.list inventory) + { + m_LSL_Functions.llGiveInventoryList(destination, category, inventory); + } + + public void llSetVehicleType(int type) + { + m_LSL_Functions.llSetVehicleType(type); + } + + public void llSetVehicledoubleParam(int param, double value) + { + m_LSL_Functions.llSetVehicledoubleParam(param, value); + } + + public void llSetVehicleFloatParam(int param, float value) + { + m_LSL_Functions.llSetVehicleFloatParam(param, value); + } + + public void llSetVehicleVectorParam(int param, vector vec) + { + m_LSL_Functions.llSetVehicleVectorParam(param, vec); + } + + public void llSetVehicleRotationParam(int param, rotation rot) + { + m_LSL_Functions.llSetVehicleRotationParam(param, rot); + } + + public void llSetVehicleFlags(int flags) + { + m_LSL_Functions.llSetVehicleFlags(flags); + } + + public void llRemoveVehicleFlags(int flags) + { + m_LSL_Functions.llRemoveVehicleFlags(flags); + } + + public void llSitTarget(vector offset, rotation rot) + { + m_LSL_Functions.llSitTarget(offset, rot); + } + + public string llAvatarOnSitTarget() + { + return m_LSL_Functions.llAvatarOnSitTarget(); + } + + public void llAddToLandPassList(string avatar, double hours) + { + m_LSL_Functions.llAddToLandPassList(avatar, hours); + } + + public void llSetTouchText(string text) + { + m_LSL_Functions.llSetTouchText(text); + } + + public void llSetSitText(string text) + { + m_LSL_Functions.llSetSitText(text); + } + + public void llSetCameraEyeOffset(vector offset) + { + m_LSL_Functions.llSetCameraEyeOffset(offset); + } + + public void llSetCameraAtOffset(vector offset) + { + m_LSL_Functions.llSetCameraAtOffset(offset); + } + + public string llDumpList2String(LSL_Types.list src, string seperator) + { + return m_LSL_Functions.llDumpList2String(src, seperator); + } + + public LSL_Types.LSLInteger llScriptDanger(vector pos) + { + return m_LSL_Functions.llScriptDanger(pos); + } + + public void llDialog(string avatar, string message, LSL_Types.list buttons, int chat_channel) + { + m_LSL_Functions.llDialog(avatar, message, buttons, chat_channel); + } + + public void llVolumeDetect(int detect) + { + m_LSL_Functions.llVolumeDetect(detect); + } + + public void llResetOtherScript(string name) + { + m_LSL_Functions.llResetOtherScript(name); + } + + public LSL_Types.LSLInteger llGetScriptState(string name) + { + return m_LSL_Functions.llGetScriptState(name); + } + + public void llRemoteLoadScript() + { + m_LSL_Functions.llRemoteLoadScript(); + } + + public void llSetRemoteScriptAccessPin(int pin) + { + m_LSL_Functions.llSetRemoteScriptAccessPin(pin); + } + + public void llRemoteLoadScriptPin(string target, string name, int pin, int running, int start_param) + { + m_LSL_Functions.llRemoteLoadScriptPin(target, name, pin, running, start_param); + } + + public void llOpenRemoteDataChannel() + { + m_LSL_Functions.llOpenRemoteDataChannel(); + } + + public string llSendRemoteData(string channel, string dest, int idata, string sdata) + { + return m_LSL_Functions.llSendRemoteData(channel, dest, idata, sdata); + } + + public void llRemoteDataReply(string channel, string message_id, string sdata, int idata) + { + m_LSL_Functions.llRemoteDataReply(channel, message_id, sdata, idata); + } + + public void llCloseRemoteDataChannel(string channel) + { + m_LSL_Functions.llCloseRemoteDataChannel(channel); + } + + public string llMD5String(string src, int nonce) + { + return m_LSL_Functions.llMD5String(src, nonce); + } + + public void llSetPrimitiveParams(LSL_Types.list rules) + { + m_LSL_Functions.llSetPrimitiveParams(rules); + } + + public void llSetLinkPrimitiveParams(int linknumber, LSL_Types.list rules) + { + m_LSL_Functions.llSetLinkPrimitiveParams(linknumber, rules); + } + public string llStringToBase64(string str) + { + return m_LSL_Functions.llStringToBase64(str); + } + + public string llBase64ToString(string str) + { + return m_LSL_Functions.llBase64ToString(str); + } + + public void llXorBase64Strings() + { + m_LSL_Functions.llXorBase64Strings(); + } + + public void llRemoteDataSetRegion() + { + m_LSL_Functions.llRemoteDataSetRegion(); + } + + public double llLog10(double val) + { + return m_LSL_Functions.llLog10(val); + } + + public double llLog(double val) + { + return m_LSL_Functions.llLog(val); + } + + public LSL_Types.list llGetAnimationList(string id) + { + return m_LSL_Functions.llGetAnimationList(id); + } + + public void llSetParcelMusicURL(string url) + { + m_LSL_Functions.llSetParcelMusicURL(url); + } + + public vector llGetRootPosition() + { + return m_LSL_Functions.llGetRootPosition(); + } + + public rotation llGetRootRotation() + { + return m_LSL_Functions.llGetRootRotation(); + } + + public string llGetObjectDesc() + { + return m_LSL_Functions.llGetObjectDesc(); + } + + public void llSetObjectDesc(string desc) + { + m_LSL_Functions.llSetObjectDesc(desc); + } + + public string llGetCreator() + { + return m_LSL_Functions.llGetCreator(); + } + + public string llGetTimestamp() + { + return m_LSL_Functions.llGetTimestamp(); + } + + public void llSetLinkAlpha(int linknumber, double alpha, int face) + { + m_LSL_Functions.llSetLinkAlpha(linknumber, alpha, face); + } + + public LSL_Types.LSLInteger llGetNumberOfPrims() + { + return m_LSL_Functions.llGetNumberOfPrims(); + } + + public string llGetNumberOfNotecardLines(string name) + { + return m_LSL_Functions.llGetNumberOfNotecardLines(name); + } + + public LSL_Types.list llGetBoundingBox(string obj) + { + return m_LSL_Functions.llGetBoundingBox(obj); + } + + public vector llGetGeometricCenter() + { + return m_LSL_Functions.llGetGeometricCenter(); + } + + public LSL_Types.list llGetPrimitiveParams(LSL_Types.list rules) + { + return m_LSL_Functions.llGetPrimitiveParams(rules); + } + + public string llIntegerToBase64(int number) + { + return m_LSL_Functions.llIntegerToBase64(number); + } + + public LSL_Types.LSLInteger llBase64ToInteger(string str) + { + return m_LSL_Functions.llBase64ToInteger(str); + } + + public double llGetGMTclock() + { + return m_LSL_Functions.llGetGMTclock(); + } + + public string llGetSimulatorHostname() + { + return m_LSL_Functions.llGetSimulatorHostname(); + } + + public void llSetLocalRot(rotation rot) + { + m_LSL_Functions.llSetLocalRot(rot); + } + + public LSL_Types.list llParseStringKeepNulls(string src, LSL_Types.list seperators, LSL_Types.list spacers) + { + return m_LSL_Functions.llParseStringKeepNulls(src, seperators, spacers); + } + + public void llRezAtRoot(string inventory, vector position, vector velocity, rotation rot, int param) + { + m_LSL_Functions.llRezAtRoot(inventory, position, velocity, rot, param); + } + + public LSL_Types.LSLInteger llGetObjectPermMask(int mask) + { + return m_LSL_Functions.llGetObjectPermMask(mask); + } + + public void llSetObjectPermMask(int mask, int value) + { + m_LSL_Functions.llSetObjectPermMask(mask, value); + } + + public LSL_Types.LSLInteger llGetInventoryPermMask(string item, int mask) + { + return m_LSL_Functions.llGetInventoryPermMask(item, mask); + } + + public void llSetInventoryPermMask(string item, int mask, int value) + { + m_LSL_Functions.llSetInventoryPermMask(item, mask, value); + } + + public string llGetInventoryCreator(string item) + { + return m_LSL_Functions.llGetInventoryCreator(item); + } + + public void llOwnerSay(string msg) + { + m_LSL_Functions.llOwnerSay(msg); + } + + public string llRequestSimulatorData(string simulator, int data) + { + return m_LSL_Functions.llRequestSimulatorData(simulator, data); + } + + public void llForceMouselook(int mouselook) + { + m_LSL_Functions.llForceMouselook(mouselook); + } + + public double llGetObjectMass(string id) + { + return m_LSL_Functions.llGetObjectMass(id); + } + + public LSL_Types.list llListReplaceList(LSL_Types.list dest, LSL_Types.list src, int start, int end) + { + return m_LSL_Functions.llListReplaceList(dest, src, start, end); + } + + public void llLoadURL(string avatar_id, string message, string url) + { + m_LSL_Functions.llLoadURL(avatar_id, message, url); + } + + public void llParcelMediaCommandList(LSL_Types.list commandList) + { + m_LSL_Functions.llParcelMediaCommandList(commandList); + } + + public void llParcelMediaQuery() + { + m_LSL_Functions.llParcelMediaQuery(); + } + + public LSL_Types.LSLInteger llModPow(int a, int b, int c) + { + return m_LSL_Functions.llModPow(a, b, c); + } + + public LSL_Types.LSLInteger llGetInventoryType(string name) + { + return m_LSL_Functions.llGetInventoryType(name); + } + + public void llSetPayPrice(int price, LSL_Types.list quick_pay_buttons) + { + m_LSL_Functions.llSetPayPrice(price, quick_pay_buttons); + } + + public vector llGetCameraPos() + { + return m_LSL_Functions.llGetCameraPos(); + } + + public rotation llGetCameraRot() + { + return m_LSL_Functions.llGetCameraRot(); + } + + public void llSetPrimURL() + { + m_LSL_Functions.llSetPrimURL(); + } + + public void llRefreshPrimURL() + { + m_LSL_Functions.llRefreshPrimURL(); + } + + public string llEscapeURL(string url) + { + return m_LSL_Functions.llEscapeURL(url); + } + + public string llUnescapeURL(string url) + { + return m_LSL_Functions.llUnescapeURL(url); + } + + public void llMapDestination(string simname, vector pos, vector look_at) + { + m_LSL_Functions.llMapDestination(simname, pos, look_at); + } + + public void llAddToLandBanList(string avatar, double hours) + { + m_LSL_Functions.llAddToLandBanList(avatar, hours); + } + + public void llRemoveFromLandPassList(string avatar) + { + m_LSL_Functions.llRemoveFromLandPassList(avatar); + } + + public void llRemoveFromLandBanList(string avatar) + { + m_LSL_Functions.llRemoveFromLandBanList(avatar); + } + + public void llSetCameraParams(LSL_Types.list rules) + { + m_LSL_Functions.llSetCameraParams(rules); + } + + public void llClearCameraParams() + { + m_LSL_Functions.llClearCameraParams(); + } + + public double llListStatistics(int operation, LSL_Types.list src) + { + return m_LSL_Functions.llListStatistics(operation, src); + } + + public LSL_Types.LSLInteger llGetUnixTime() + { + return m_LSL_Functions.llGetUnixTime(); + } + + public LSL_Types.LSLInteger llGetParcelFlags(vector pos) + { + return m_LSL_Functions.llGetParcelFlags(pos); + } + + public LSL_Types.LSLInteger llGetRegionFlags() + { + return m_LSL_Functions.llGetRegionFlags(); + } + + public string llXorBase64StringsCorrect(string str1, string str2) + { + return m_LSL_Functions.llXorBase64StringsCorrect(str1, str2); + } + + public string llHTTPRequest(string url, LSL_Types.list parameters, string body) + { + return m_LSL_Functions.llHTTPRequest(url, parameters, body); + } + + public void llResetLandBanList() + { + m_LSL_Functions.llResetLandBanList(); + } + + public void llResetLandPassList() + { + m_LSL_Functions.llResetLandPassList(); + } + + public LSL_Types.LSLInteger llGetParcelPrimCount(vector pos, int category, int sim_wide) + { + return m_LSL_Functions.llGetParcelPrimCount(pos, category, sim_wide); + } + + public LSL_Types.list llGetParcelPrimOwners(vector pos) + { + return m_LSL_Functions.llGetParcelPrimOwners(pos); + } + + public LSL_Types.LSLInteger llGetObjectPrimCount(string object_id) + { + return m_LSL_Functions.llGetObjectPrimCount(object_id); + } + + public LSL_Types.LSLInteger llGetParcelMaxPrims(vector pos, int sim_wide) + { + return m_LSL_Functions.llGetParcelMaxPrims(pos, sim_wide); + } + + public LSL_Types.list llGetParcelDetails(vector pos, LSL_Types.list param) + { + return m_LSL_Functions.llGetParcelDetails(pos, param); + } + + public void llSetLinkTexture(int linknumber, string texture, int face) + { + m_LSL_Functions.llSetLinkTexture(linknumber, texture, face); + } + + public string llStringTrim(string src, int type) + { + return m_LSL_Functions.llStringTrim(src, type); + } + + public LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args) + { + return m_LSL_Functions.llGetObjectDetails(id, args); + } + + public double llList2Float(LSL_Types.list src, int index) + { + return m_LSL_Functions.llList2Float(src, index); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs new file mode 100644 index 0000000..168804d --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs @@ -0,0 +1,199 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Runtime.Remoting.Lifetime; +using System.Threading; +using System.Reflection; +using System.Collections; +using System.Collections.Generic; +using OpenSim.Region.Environment.Interfaces; +using OpenSim.Region.ScriptEngine.Interfaces; +using OpenSim.Region.ScriptEngine.Shared.Api.Interfaces; +using integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger; +using key = System.String; +using vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3; +using rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion; + +namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase +{ + public partial class ScriptBaseClass : MarshalByRefObject + { + public IOSSL_Api m_OSSL_Functions; + + public void ApiTypeOSSL(IScriptApi api) + { + if(!(api is IOSSL_Api)) + return; + + m_OSSL_Functions = (IOSSL_Api)api; + } + + public void osSetRegionWaterHeight(double height) + { + m_OSSL_Functions.osSetRegionWaterHeight(height); + } + + public double osList2Double(LSL_Types.list src, int index) + { + return m_OSSL_Functions.osList2Double(src, index); + } + + public string osSetDynamicTextureURL(string dynamicID, string contentType, string url, string extraParams, + int timer) + { + return m_OSSL_Functions.osSetDynamicTextureURL(dynamicID, contentType, url, extraParams, timer); + } + + public string osSetDynamicTextureData(string dynamicID, string contentType, string data, string extraParams, + int timer) + { + return m_OSSL_Functions.osSetDynamicTextureData(dynamicID, contentType, data, extraParams, timer); + } + + public string osSetDynamicTextureURLBlend(string dynamicID, string contentType, string url, string extraParams, + int timer, int alpha) + { + return m_OSSL_Functions.osSetDynamicTextureURLBlend(dynamicID, contentType, url, extraParams, timer, alpha); + } + + public string osSetDynamicTextureDataBlend(string dynamicID, string contentType, string data, string extraParams, + int timer, int alpha) + { + return m_OSSL_Functions.osSetDynamicTextureDataBlend(dynamicID, contentType, data, extraParams, timer, alpha); + } + + public double osTerrainGetHeight(int x, int y) + { + return m_OSSL_Functions.osTerrainGetHeight(x, y); + } + + public int osTerrainSetHeight(int x, int y, double val) + { + return m_OSSL_Functions.osTerrainSetHeight(x, y, val); + } + + public int osRegionRestart(double seconds) + { + return m_OSSL_Functions.osRegionRestart(seconds); + } + + public void osRegionNotice(string msg) + { + m_OSSL_Functions.osRegionNotice(msg); + } + + public bool osConsoleCommand(string Command) + { + return m_OSSL_Functions.osConsoleCommand(Command); + } + + public void osSetParcelMediaURL(string url) + { + m_OSSL_Functions.osSetParcelMediaURL(url); + } + + public void osSetPrimFloatOnWater(int floatYN) + { + m_OSSL_Functions.osSetPrimFloatOnWater(floatYN); + } + + // Animation Functions + + public void osAvatarPlayAnimation(string avatar, string animation) + { + m_OSSL_Functions.osAvatarPlayAnimation(avatar, animation); + } + + public void osAvatarStopAnimation(string avatar, string animation) + { + m_OSSL_Functions.osAvatarStopAnimation(avatar, animation); + } + + + //Texture Draw functions + + public string osMovePen(string drawList, int x, int y) + { + return m_OSSL_Functions.osMovePen(drawList, x, y); + } + + public string osDrawLine(string drawList, int startX, int startY, int endX, int endY) + { + return m_OSSL_Functions.osDrawLine(drawList, startX, startY, endX, endY); + } + + public string osDrawLine(string drawList, int endX, int endY) + { + return m_OSSL_Functions.osDrawLine(drawList, endX, endY); + } + + public string osDrawText(string drawList, string text) + { + return m_OSSL_Functions.osDrawText(drawList, text); + } + + public string osDrawEllipse(string drawList, int width, int height) + { + return m_OSSL_Functions.osDrawEllipse(drawList, width, height); + } + + public string osDrawRectangle(string drawList, int width, int height) + { + return m_OSSL_Functions.osDrawRectangle(drawList, width, height); + } + + public string osDrawFilledRectangle(string drawList, int width, int height) + { + return m_OSSL_Functions.osDrawFilledRectangle(drawList, width, height); + } + + public string osSetFontSize(string drawList, int fontSize) + { + return m_OSSL_Functions.osSetFontSize(drawList, fontSize); + } + + public string osSetPenSize(string drawList, int penSize) + { + return m_OSSL_Functions.osSetPenSize(drawList, penSize); + } + + public string osSetPenColour(string drawList, string colour) + { + return m_OSSL_Functions.osSetPenColour(drawList, colour); + } + + public string osDrawImage(string drawList, int width, int height, string imageUrl) + { + return m_OSSL_Functions.osDrawImage(drawList, width, height, imageUrl); + } + public void osSetStateEvents(int events) + { + m_OSSL_Functions.osSetStateEvents(events); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj new file mode 100644 index 0000000..870da9f --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj @@ -0,0 +1,161 @@ + + + Local + 9.0.21022 + 2.0 + {21BC44EA-0000-0000-0000-000000000000} + Debug + AnyCPU + + + + OpenSim.Region.ScriptEngine.Shared.Api.Runtime + JScript + Grid + IE50 + false + Library + + OpenSim.Region.ScriptEngine.Shared.Api.Runtime + + + + + + False + 285212672 + False + + + TRACE;DEBUG + + True + 4096 + False + ..\..\..\..\..\..\bin\ + False + False + False + 4 + + + + False + 285212672 + False + + + TRACE + + False + 4096 + True + ..\..\..\..\..\..\bin\ + False + False + False + 4 + + + + + ..\..\..\..\..\..\bin\Axiom.MathLib.dll + False + + + ..\..\..\..\..\..\bin\libsecondlife.dll + False + + + ..\..\..\..\..\..\bin\log4net.dll + False + + + ..\..\..\..\..\..\bin\Nini.dll + False + + + ..\..\..\..\..\..\bin\Nini.dll + False + + + ..\..\..\..\..\..\bin\RAIL.dll + False + + + System.dll + False + + + System.Data.dll + False + + + System.Web.dll + False + + + System.Xml.dll + False + + + + + OpenSim + {438A9556-0000-0000-0000-000000000000} + {FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + False + + + OpenSim.Framework + {8ACA2445-0000-0000-0000-000000000000} + {FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + False + + + OpenSim.Framework.Communications + {CB52B7E7-0000-0000-0000-000000000000} + {FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + False + + + OpenSim.Framework.Console + {A7CD0630-0000-0000-0000-000000000000} + {FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + False + + + OpenSim.Region.Environment + {DCBA491C-0000-0000-0000-000000000000} + {FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + False + + + OpenSim.Region.ScriptEngine.Shared + {D9F1B557-0000-0000-0000-000000000000} + {FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + False + + + + + Code + + + Code + + + Code + + + Code + + + + + + + + + + diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj.user b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj.user new file mode 100644 index 0000000..c28f556 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj.user @@ -0,0 +1,12 @@ + + + Debug + AnyCPU + C:\Data\OpenSim\bin\ + 9.0.21022 + ProjectFiles + 0 + + + + diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.dll.build b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.dll.build new file mode 100644 index 0000000..c3af05c --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.dll.build @@ -0,0 +1,62 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.mdp b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.mdp new file mode 100644 index 0000000..37bedfc --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.mdp @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs new file mode 100644 index 0000000..aa2c9c2 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs @@ -0,0 +1,124 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Runtime.Remoting.Lifetime; +using System.Threading; +using System.Reflection; +using System.Collections; +using System.Collections.Generic; +using OpenSim.Region.ScriptEngine.Interfaces; +using OpenSim.Region.ScriptEngine.Shared; + +namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase +{ + public partial class ScriptBaseClass : MarshalByRefObject, IScript + { + private Dictionary inits = new Dictionary(); + + public ScriptBaseClass() + { + MethodInfo[] myArrayMethodInfo = GetType().GetMethods(BindingFlags.Public|BindingFlags.Instance); + + foreach(MethodInfo mi in myArrayMethodInfo) + { + if(mi.Name.Length > 7 && mi.Name.Substring(0, 7) == "ApiType") + { + string type=mi.Name.Substring(7); + inits[type]=mi; + } + } + } + + public string[] GetApis() + { + string[] apis = new string[inits.Count]; + inits.Keys.CopyTo(apis, 0); + return apis; + } + + public void InitApi(string api, IScriptApi data) + { + if(!inits.ContainsKey(api)) + return; + + MethodInfo mi = inits[api]; + + Object[] args = new Object[1]; + args[0] = data; + + mi.Invoke(this, args); + } + + private Dictionary m_InitialValues = + new Dictionary(); + private Dictionary m_Fields = + new Dictionary(); + + public Dictionary GetVars() + { + Dictionary vars = new Dictionary(); + + if (m_Fields == null) + return vars; + + m_Fields.Clear(); + + Type t = GetType(); + + FieldInfo[] fields = t.GetFields(BindingFlags.NonPublic | + BindingFlags.Public | + BindingFlags.Instance | + BindingFlags.DeclaredOnly); + + foreach (FieldInfo field in fields) + { + m_Fields[field.Name]=field; + + vars[field.Name]=field.GetValue(this); + } + + return vars; + } + + public void SetVars(Dictionary vars) + { + foreach (KeyValuePair var in vars) + { + if (m_Fields.ContainsKey(var.Key)) + { + m_Fields[var.Key].SetValue(this, var.Value); + } + } + } + + public void ResetVars() + { + SetVars(m_InitialValues); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Atom.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Atom.cs new file mode 100644 index 0000000..27ab04e --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Atom.cs @@ -0,0 +1,218 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + public class Atom : IUnifiable + { + private static Dictionary _atomStore = new Dictionary(); + public readonly string _name; + public readonly Atom _module; + + /// + /// You should not call this constructor, but use Atom.a instead. + /// + /// + /// + private Atom(string name, Atom module) + { + _name = name; + _module = module; + } + + /// + /// Return the unique Atom object for name where module is null. You should use this to create + /// an Atom instead of calling the Atom constructor. + /// + /// + /// + public static Atom a(string name) + { + Atom atom; + if (!_atomStore.TryGetValue(name, out atom)) + { + atom = new Atom(name, null); + _atomStore[name] = atom; + } + return atom; + } + + /// + /// Return an Atom object with the name and module. If module is null or Atom.NIL, + /// this behaves like Atom.a(name) and returns the unique object where the module is null. + /// If module is not null or Atom.NIL, this may or may not be the same object as another Atom + /// with the same name and module. + /// + /// + /// + /// + public static Atom a(string name, Atom module) + { + if (module == null || module == Atom.NIL) + return a(name); + return new Atom(name, module); + } + + /// + /// If Obj is an Atom unify its _module with Module. If the Atom's _module is null, use Atom.NIL. + /// + /// + /// + /// + public static IEnumerable module(object Obj, object Module) + { + Obj = YP.getValue(Obj); + if (Obj is Atom) + { + if (((Atom)Obj)._module == null) + return YP.unify(Module, Atom.NIL); + else + return YP.unify(Module, ((Atom)Obj)._module); + } + return YP.fail(); + } + + public static readonly Atom NIL = Atom.a("[]"); + public static readonly Atom DOT = Atom.a("."); + public static readonly Atom F = Atom.a("f"); + public static readonly Atom SLASH = Atom.a("/"); + public static readonly Atom HAT = Atom.a("^"); + public static readonly Atom RULE = Atom.a(":-"); + + public IEnumerable unify(object arg) + { + arg = YP.getValue(arg); + if (arg is Atom) + return Equals(arg) ? YP.succeed() : YP.fail(); + else if (arg is Variable) + return ((Variable)arg).unify(this); + else + return YP.fail(); + } + + public void addUniqueVariables(List variableSet) + { + // Atom does not contain variables. + } + + public object makeCopy(Variable.CopyStore copyStore) + { + // Atom does not contain variables that need to be copied. + return this; + } + + public bool termEqual(object term) + { + return Equals(YP.getValue(term)); + } + + public bool ground() + { + // Atom is always ground. + return true; + } + + public override bool Equals(object obj) + { + if (obj is Atom) + { + if (_module == null && ((Atom)obj)._module == null) + // When _declaringClass is null, we always use an identical object from _atomStore. + return this == obj; + // Otherwise, ignore _declaringClass and do a normal string compare on the _name. + return _name == ((Atom)obj)._name; + } + return false; + } + + public override string ToString() + { + return _name; + } + + public override int GetHashCode() + { + // Debug: need to check _declaringClass. + return _name.GetHashCode(); + } + + public string toQuotedString() + { + if (_name.Length == 0) + return "''"; + else if (this == Atom.NIL) + return "[]"; + + StringBuilder result = new StringBuilder(_name.Length); + bool useQuotes = false; + foreach (char c in _name) + { + int cInt = (int)c; + if (c == '\'') + { + result.Append("''"); + useQuotes = true; + } + else if (c == '_' || cInt >= (int)'a' && cInt <= (int)'z' || + cInt >= (int)'A' && cInt <= (int)'Z' || cInt >= (int)'0' && cInt <= (int)'9') + result.Append(c); + else + { + // Debug: Need to handle non-printable chars. + result.Append(c); + useQuotes = true; + } + } + + if (!useQuotes && (int)_name[0] >= (int)'a' && (int)_name[0] <= (int)'z') + return result.ToString(); + else + { + // Surround in single quotes. + result.Append('\''); + return "'" + result; + } + } + + /// + /// Return true if _name is lexicographically less than atom._name. + /// + /// + /// + public bool lessThan(Atom atom) + { + return _name.CompareTo(atom._name) < 0; + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/BagofAnswers.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/BagofAnswers.cs new file mode 100644 index 0000000..70c1b5a --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/BagofAnswers.cs @@ -0,0 +1,234 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections; +using System.Collections.Generic; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + /// + /// A BagofAnswers holds answers for bagof and setof. + /// + public class BagofAnswers + { + private object _template; + private Variable[] _freeVariables; + private Dictionary> _bagForFreeVariables; + private List _findallBagArray; + private static TermArrayEqualityComparer _termArrayEqualityComparer = + new TermArrayEqualityComparer(); + + /// + /// To get the free variables, split off any existential qualifiers from Goal such as the X in + /// "X ^ f(Y)", get the set of unbound variables in Goal that are not qualifiers, then remove + /// the unbound variables that are qualifiers as well as the unbound variables in Template. + /// + /// + /// + public BagofAnswers(object Template, object Goal) + { + _template = Template; + + // First get the set of variables that are not free variables. + List variableSet = new List(); + YP.addUniqueVariables(Template, variableSet); + object UnqualifiedGoal = YP.getValue(Goal); + while (UnqualifiedGoal is Functor2 && ((Functor2)UnqualifiedGoal)._name == Atom.HAT) + { + YP.addUniqueVariables(((Functor2)UnqualifiedGoal)._arg1, variableSet); + UnqualifiedGoal = YP.getValue(((Functor2)UnqualifiedGoal)._arg2); + } + + // Remember how many non-free variables there are so we can find the unique free variables + // that are added. + int nNonFreeVariables = variableSet.Count; + YP.addUniqueVariables(UnqualifiedGoal, variableSet); + int nFreeVariables = variableSet.Count - nNonFreeVariables; + if (nFreeVariables == 0) + { + // There were no free variables added, so we won't waste time with _bagForFreeVariables. + _freeVariables = null; + _findallBagArray = new List(); + } + else + { + // Copy the free variables. + _freeVariables = new Variable[nFreeVariables]; + for (int i = 0; i < nFreeVariables; ++i) + _freeVariables[i] = variableSet[i + nNonFreeVariables]; + + _bagForFreeVariables = new Dictionary>(_termArrayEqualityComparer); + } + } + + public void add() + { + if (_freeVariables == null) + // The goal has bound the values in _template but we don't bother with _freeVariables. + _findallBagArray.Add(YP.makeCopy(_template, new Variable.CopyStore())); + else + { + // The goal has bound the values in _template and _freeVariables. + // Find the entry for this set of _freeVariables values. + object[] freeVariableValues = new object[_freeVariables.Length]; + for (int i = 0; i < _freeVariables.Length; ++i) + freeVariableValues[i] = YP.getValue(_freeVariables[i]); + List bagArray; + if (!_bagForFreeVariables.TryGetValue(freeVariableValues, out bagArray)) + { + bagArray = new List(); + _bagForFreeVariables[freeVariableValues] = bagArray; + } + + // Now copy the template and add to the bag for the freeVariables values. + bagArray.Add(YP.makeCopy(_template, new Variable.CopyStore())); + } + } + + /// + /// For each result, unify the _freeVariables and unify bagArrayVariable with the associated bag. + /// + /// this is unified with the List of matches for template that + /// corresponds to the bindings for freeVariables. Be very careful: this does not unify with a Prolog + /// list. + /// + public IEnumerable resultArray(Variable bagArrayVariable) + { + if (_freeVariables == null) + { + // No unbound free variables, so we only filled one bag. If empty, bagof fails. + if (_findallBagArray.Count > 0) + { + foreach (bool l1 in bagArrayVariable.unify(_findallBagArray)) + yield return false; + } + } + else + { + foreach (KeyValuePair> valuesAndBag in _bagForFreeVariables) + { + foreach (bool l1 in YP.unifyArrays(_freeVariables, valuesAndBag.Key)) + { + foreach (bool l2 in bagArrayVariable.unify(valuesAndBag.Value)) + yield return false; + } + // Debug: Should we free memory of the answers already returned? + } + } + } + + /// + /// For each result, unify the _freeVariables and unify Bag with the associated bag. + /// + /// + /// + public IEnumerable result(object Bag) + { + Variable bagArrayVariable = new Variable(); + foreach (bool l1 in resultArray(bagArrayVariable)) + { + foreach (bool l2 in YP.unify(Bag, ListPair.make((List)bagArrayVariable.getValue()))) + yield return false; + } + } + + /// + /// For each result, unify the _freeVariables and unify Bag with the associated bag which is sorted + /// with duplicates removed, as in setof. + /// + /// + /// + public IEnumerable resultSet(object Bag) + { + Variable bagArrayVariable = new Variable(); + foreach (bool l1 in resultArray(bagArrayVariable)) + { + List bagArray = (List)bagArrayVariable.getValue(); + YP.sortArray(bagArray); + foreach (bool l2 in YP.unify(Bag, ListPair.makeWithoutRepeatedTerms(bagArray))) + yield return false; + } + } + + public static IEnumerable bagofArray + (object Template, object Goal, IEnumerable goalIterator, Variable bagArrayVariable) + { + BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal); + foreach (bool l1 in goalIterator) + bagOfAnswers.add(); + return bagOfAnswers.resultArray(bagArrayVariable); + } + + public static IEnumerable bagof + (object Template, object Goal, IEnumerable goalIterator, object Bag) + { + BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal); + foreach (bool l1 in goalIterator) + bagOfAnswers.add(); + return bagOfAnswers.result(Bag); + } + + public static IEnumerable setof + (object Template, object Goal, IEnumerable goalIterator, object Bag) + { + BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal); + foreach (bool l1 in goalIterator) + bagOfAnswers.add(); + return bagOfAnswers.resultSet(Bag); + } + + /// + /// A TermArrayEqualityComparer implements IEqualityComparer to compare two object arrays using YP.termEqual. + /// + private class TermArrayEqualityComparer : IEqualityComparer + { + public bool Equals(object[] array1, object[] array2) + { + if (array1.Length != array2.Length) + return false; + for (int i = 0; i < array1.Length; ++i) + { + if (!YP.termEqual(array1[i], array2[i])) + return false; + } + return true; + } + + public int GetHashCode(object[] array) + { + int hashCode = 0; + for (int i = 0; i < array.Length; ++i) + hashCode ^= array[i].GetHashCode(); + return hashCode; + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/FindallAnswers.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/FindallAnswers.cs new file mode 100644 index 0000000..28709e1 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/FindallAnswers.cs @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections; +using System.Collections.Generic; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + /// + /// A FindallAnswers holds answers for findall. + /// + public class FindallAnswers + { + private object _template; + private List _bagArray; + + public FindallAnswers(object Template) + { + _template = Template; + _bagArray = new List(); + } + + public void add() + { + _bagArray.Add(YP.makeCopy(_template, new Variable.CopyStore())); + } + + public List resultArray() + { + return _bagArray; + } + + /// + /// Unify Bag with the result. This frees the internal answers, so you can only call this once. + /// + /// + /// + public IEnumerable result(object Bag) + { + object result = ListPair.make(_bagArray); + // Try to free the memory. + _bagArray = null; + return YP.unify(Bag, result); + } + + /// + /// This is a simplified findall when the goal is a single call. + /// + /// + /// + /// + /// + public static IEnumerable findall(object Template, IEnumerable goal, object Bag) + { + FindallAnswers findallAnswers = new FindallAnswers(Template); + foreach (bool l1 in goal) + findallAnswers.add(); + return findallAnswers.result(Bag); + } + + /// + /// Like findall, except return an array of the results. + /// + /// + /// + /// + public static List findallArray(object Template, IEnumerable goal) + { + FindallAnswers findallAnswers = new FindallAnswers(Template); + foreach (bool l1 in goal) + findallAnswers.add(); + return findallAnswers.resultArray(); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor.cs new file mode 100644 index 0000000..8ef8de0 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor.cs @@ -0,0 +1,188 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections.Generic; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + public class Functor : IUnifiable + { + public readonly Atom _name; + public readonly object[] _args; + + public Functor(Atom name, object[] args) + { + if (args.Length <= 3) + { + if (args.Length == 0) + throw new Exception("For arity 0 functor, just use name as an Atom"); + else if (args.Length == 1) + throw new Exception("For arity 1 functor, use Functor1"); + else if (args.Length == 2) + throw new Exception("For arity 2 functor, use Functor2"); + else if (args.Length == 3) + throw new Exception("For arity 3 functor, use Functor3"); + else + // (This shouldn't happen, but include it for completeness. + throw new Exception("Cannot create a Functor of arity " + args.Length); + } + + _name = name; + _args = args; + } + + public Functor(string name, object[] args) + : this(Atom.a(name), args) + { + } + + /// + /// Return an Atom, Functor1, Functor2, Functor3 or Functor depending on the + /// length of args. + /// Note that this is different than the Functor constructor which requires + /// the length of args to be greater than 3. + /// + /// + /// + /// + public static object make(Atom name, object[] args) + { + if (args.Length <= 0) + return name; + else if (args.Length == 1) + return new Functor1(name, args[0]); + else if (args.Length == 2) + return new Functor2(name, args[0], args[1]); + else if (args.Length == 3) + return new Functor3(name, args[0], args[1], args[2]); + else + return new Functor(name, args); + } + + /// + /// Call the main make, first converting name to an Atom. + /// + /// + /// + /// + public static object make(string name, object[] args) + { + return make(Atom.a(name), args); + } + + public IEnumerable unify(object arg) + { + arg = YP.getValue(arg); + if (arg is Functor) + { + Functor argFunctor = (Functor)arg; + if (_name.Equals(argFunctor._name)) + return YP.unifyArrays(_args, argFunctor._args); + else + return YP.fail(); + } + else if (arg is Variable) + return ((Variable)arg).unify(this); + else + return YP.fail(); + } + + public override string ToString() + { + string result = _name + "(" + YP.getValue(_args[0]); + for (int i = 1; i < _args.Length; ++i) + result += ", " + YP.getValue(_args[i]); + result += ")"; + return result; + } + + public bool termEqual(object term) + { + term = YP.getValue(term); + if (term is Functor) + { + Functor termFunctor = (Functor)term; + if (_name.Equals(termFunctor._name) && _args.Length == termFunctor._args.Length) + { + for (int i = 0; i < _args.Length; ++i) + { + if (!YP.termEqual(_args[i], termFunctor._args[i])) + return false; + } + return true; + } + } + return false; + } + + public bool lessThan(Functor functor) + { + // Do the equal check first since it is faster. + if (!_name.Equals(functor._name)) + return _name.lessThan(functor._name); + + if (_args.Length != functor._args.Length) + return _args.Length < functor._args.Length; + + for (int i = 0; i < _args.Length; ++i) + { + if (!YP.termEqual(_args[i], functor._args[i])) + return YP.termLessThan(_args[i], functor._args[i]); + } + + return false; + } + + public bool ground() + { + for (int i = 0; i < _args.Length; ++i) + { + if (!YP.ground(_args[i])) + return false; + } + return true; + } + + public void addUniqueVariables(List variableSet) + { + for (int i = 0; i < _args.Length; ++i) + YP.addUniqueVariables(_args[i], variableSet); + } + + public object makeCopy(Variable.CopyStore copyStore) + { + object[] argsCopy = new object[_args.Length]; + for (int i = 0; i < _args.Length; ++i) + argsCopy[i] = YP.makeCopy(_args[i], copyStore); + return new Functor(_name, argsCopy); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor1.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor1.cs new file mode 100644 index 0000000..3c0c1c4 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor1.cs @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections.Generic; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + public class Functor1 : IUnifiable + { + public readonly Atom _name; + public readonly object _arg1; + + public Functor1(Atom name, object arg1) + { + _name = name; + _arg1 = arg1; + } + + public Functor1(string name, object arg1) + : this(Atom.a(name), arg1) + { + } + + public IEnumerable unify(object arg) + { + arg = YP.getValue(arg); + if (arg is Functor1) + { + Functor1 argFunctor = (Functor1)arg; + if (_name.Equals(argFunctor._name)) + { + foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1)) + yield return false; + } + } + else if (arg is Variable) + { + foreach (bool l1 in ((Variable)arg).unify(this)) + yield return false; + } + } + + public override string ToString() + { + return _name + "(" + YP.getValue(_arg1) + ")"; + } + + public bool termEqual(object term) + { + term = YP.getValue(term); + if (term is Functor1) + { + Functor1 termFunctor = (Functor1)term; + return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1); + } + return false; + } + + public bool lessThan(Functor1 functor) + { + // Do the equal check first since it is faster. + if (!_name.Equals(functor._name)) + return _name.lessThan(functor._name); + + return YP.termLessThan(_arg1, functor._arg1); + } + + public bool ground() + { + return YP.ground(_arg1); + } + + public void addUniqueVariables(List variableSet) + { + YP.addUniqueVariables(_arg1, variableSet); + } + + public object makeCopy(Variable.CopyStore copyStore) + { + return new Functor1(_name, YP.makeCopy(_arg1, copyStore)); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor2.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor2.cs new file mode 100644 index 0000000..596b763 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor2.cs @@ -0,0 +1,154 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections.Generic; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + public class Functor2 : IUnifiable + { + public readonly Atom _name; + public readonly object _arg1; + public readonly object _arg2; + + public Functor2(Atom name, object arg1, object arg2) + { + _name = name; + _arg1 = arg1; + _arg2 = arg2; + } + + public Functor2(string name, object arg1, object arg2) + : this(Atom.a(name), arg1, arg2) + { + } + + public IEnumerable unify(object arg) + { + arg = YP.getValue(arg); + if (arg is Functor2) + { + Functor2 argFunctor = (Functor2)arg; + if (_name.Equals(argFunctor._name)) + { + foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1)) + { + foreach (bool l2 in YP.unify(_arg2, argFunctor._arg2)) + yield return false; + } + } + } + else if (arg is Variable) + { + foreach (bool l1 in ((Variable)arg).unify(this)) + yield return false; + } + } + + public override string ToString() + { + if (_name == Atom.DOT) + return listPairToString(this); + else + return _name + "(" + YP.getValue(_arg1) + ", " + YP.getValue(_arg2) + ")"; + } + + public bool termEqual(object term) + { + term = YP.getValue(term); + if (term is Functor2) + { + Functor2 termFunctor = (Functor2)term; + return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1) + && YP.termEqual(_arg2, termFunctor._arg2); + } + return false; + } + + public bool lessThan(Functor2 functor) + { + // Do the equal check first since it is faster. + if (!_name.Equals(functor._name)) + return _name.lessThan(functor._name); + + if (!YP.termEqual(_arg1, functor._arg1)) + return YP.termLessThan(_arg1, functor._arg1); + + return YP.termLessThan(_arg2, functor._arg2); + } + + public bool ground() + { + return YP.ground(_arg1) && YP.ground(_arg2); + } + + public void addUniqueVariables(List variableSet) + { + YP.addUniqueVariables(_arg1, variableSet); + YP.addUniqueVariables(_arg2, variableSet); + } + + public object makeCopy(Variable.CopyStore copyStore) + { + return new Functor2(_name, YP.makeCopy(_arg1, copyStore), + YP.makeCopy(_arg2, copyStore)); + } + + private static string listPairToString(Functor2 listPair) + { + string result = "["; + while (true) + { + object head = YP.getValue(listPair._arg1); + object tail = YP.getValue(listPair._arg2); + if (tail == (object)Atom.NIL) + { + result += head; + break; + } + else if (tail is Functor2 && ((Functor2)tail)._name == Atom.DOT) + { + result += head + ", "; + listPair = (Functor2)tail; + // Loop again. + } + else + { + // The list is not terminated with NIL. + result += head + "|" + tail; + break; + } + } + result += "]"; + return result; + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor3.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor3.cs new file mode 100644 index 0000000..041cceb --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor3.cs @@ -0,0 +1,133 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections.Generic; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + public class Functor3 : IUnifiable + { + public readonly Atom _name; + public readonly object _arg1; + public readonly object _arg2; + public readonly object _arg3; + + public Functor3(Atom name, object arg1, object arg2, object arg3) + { + _name = name; + _arg1 = arg1; + _arg2 = arg2; + _arg3 = arg3; + } + + public Functor3(string name, object arg1, object arg2, object arg3) + : this(Atom.a(name), arg1, arg2, arg3) + { + } + + public IEnumerable unify(object arg) + { + arg = YP.getValue(arg); + if (arg is Functor3) + { + Functor3 argFunctor = (Functor3)arg; + if (_name.Equals(argFunctor._name)) + { + foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1)) + { + foreach (bool l2 in YP.unify(_arg2, argFunctor._arg2)) + { + foreach (bool l3 in YP.unify(_arg3, argFunctor._arg3)) + yield return false; + } + } + } + } + else if (arg is Variable) + { + foreach (bool l1 in ((Variable)arg).unify(this)) + yield return false; + } + } + + public override string ToString() + { + return _name + "(" + YP.getValue(_arg1) + ", " + YP.getValue(_arg2) + ", " + + YP.getValue(_arg3) + ")"; + } + + public bool termEqual(object term) + { + term = YP.getValue(term); + if (term is Functor3) + { + Functor3 termFunctor = (Functor3)term; + return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1) + && YP.termEqual(_arg2, termFunctor._arg2) + && YP.termEqual(_arg3, termFunctor._arg3); + } + return false; + } + + public bool lessThan(Functor3 functor) + { + // Do the equal check first since it is faster. + if (!_name.Equals(functor._name)) + return _name.lessThan(functor._name); + + if (!YP.termEqual(_arg1, functor._arg1)) + return YP.termLessThan(_arg1, functor._arg1); + + if (!YP.termEqual(_arg2, functor._arg2)) + return YP.termLessThan(_arg2, functor._arg2); + + return YP.termLessThan(_arg3, functor._arg3); + } + + public bool ground() + { + return YP.ground(_arg1) && YP.ground(_arg2) && YP.ground(_arg3); + } + + public void addUniqueVariables(List variableSet) + { + YP.addUniqueVariables(_arg1, variableSet); + YP.addUniqueVariables(_arg2, variableSet); + YP.addUniqueVariables(_arg3, variableSet); + } + + public object makeCopy(Variable.CopyStore copyStore) + { + return new Functor3(_name, YP.makeCopy(_arg1, copyStore), + YP.makeCopy(_arg2, copyStore), YP.makeCopy(_arg3, copyStore)); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/IndexedAnswers.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/IndexedAnswers.cs new file mode 100644 index 0000000..1be73f7 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/IndexedAnswers.cs @@ -0,0 +1,288 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections; +using System.Collections.Generic; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + /// + /// An IndexedAnswers holds answers to a query based on the values of index arguments. + /// + public class IndexedAnswers : YP.IClause + { + // addAnswer adds the answer here and indexes it later. + private List _allAnswers = new List(); + // The key has the arity of answers with non-null values for each indexed arg. The value + // is a list of the matching answers. The signature is implicit in the pattern on non-null index args. + private Dictionary> _indexedAnswers = + new Dictionary>(); + // Keeps track of whether we have started adding entries to _indexedAnswers for the signature. + private Dictionary _gotAnswersForSignature = new Dictionary(); + private const int MAX_INDEX_ARGS = 31; + + public IndexedAnswers() + { + } + + /// + /// Elements of answer must be ground, since arguments with unbound variables make this + /// into a dynamic rule which we don't index. + /// + /// + public void addAnswer(object[] answer) + { + // Store a copy of the answer array. + object[] answerCopy = new object[answer.Length]; + Variable.CopyStore copyStore = new Variable.CopyStore(); + for (int i = 0; i < answer.Length; ++i) + answerCopy[i] = YP.makeCopy(answer[i], copyStore); + if (copyStore.getNUniqueVariables() > 0) + throw new InvalidOperationException + ("Elements of answer must be ground, but found " + copyStore.getNUniqueVariables() + + " unbound variables"); + _allAnswers.Add(answerCopy); + + // If match has already indexed answers for a signature, we need to add + // this to the existing indexed answers. + foreach (int signature in _gotAnswersForSignature.Keys) + indexAnswerForSignature(answerCopy, signature); + } + + private void indexAnswerForSignature(object[] answer, int signature) + { + // First find out which of the answer values can be used as an index. + object[] indexValues = new object[answer.Length]; + for (int i = 0; i < answer.Length; ++i) + { + // We limit the number of indexed args in a 32-bit signature. + if (i >= MAX_INDEX_ARGS) + indexValues[i] = null; + else + indexValues[i] = getIndexValue(YP.getValue(answer[i])); + } + + // We need an entry in indexArgs from indexValues for each 1 bit in signature. + HashedList indexArgs = new HashedList(indexValues.Length); + for (int i = 0; i < indexValues.Length; ++i) + { + if ((signature & (1 << i)) == 0) + indexArgs.Add(null); + else + { + if (indexValues[i] == null) + // The signature wants an index value here, but we don't have one so + // we can't add it as an answer for this signature. + return; + else + indexArgs.Add(indexValues[i]); + } + } + + // Add the answer to the answers list for indexArgs, creating the entry if needed. + List answers; + if (!_indexedAnswers.TryGetValue(indexArgs, out answers)) + { + answers = new List(); + _indexedAnswers[indexArgs] = answers; + } + answers.Add(answer); + } + + public IEnumerable match(object[] arguments) + { + // Set up indexArgs, up to arg position MAX_INDEX_ARGS. The signature has a 1 bit for + // each non-null index arg. + HashedList indexArgs = new HashedList(arguments.Length); + bool gotAllIndexArgs = true; + int signature = 0; + for (int i = 0; i < arguments.Length; ++i) + { + object indexValue = null; + if (i < MAX_INDEX_ARGS) + { + // We limit the number of args in a 32-bit signature. + indexValue = getIndexValue(YP.getValue(arguments[i])); + if (indexValue != null) + signature += (1 << i); + } + if (indexValue == null) + gotAllIndexArgs = false; + indexArgs.Add(indexValue); + } + + List answers; + if (signature == 0) + // No index args, so we have to match from _allAnswers. + answers = _allAnswers; + else + { + if (!_gotAnswersForSignature.ContainsKey(signature)) + { + // We need to create the entry in _indexedAnswers. + foreach (object[] answer in _allAnswers) + indexAnswerForSignature(answer, signature); + // Mark that we did this signature. + _gotAnswersForSignature[signature] = null; + } + if (!_indexedAnswers.TryGetValue(indexArgs, out answers)) + yield break; + } + + if (gotAllIndexArgs) + { + // All the arguments were already bound, so we don't need to do bindings. + yield return false; + yield break; + } + + // Find matches in answers. + IEnumerator[] iterators = new IEnumerator[arguments.Length]; + foreach (object[] answer in answers) + { + bool gotMatch = true; + int nIterators = 0; + // Try to bind all the arguments. + for (int i = 0; i < arguments.Length; ++i) + { + if (indexArgs[i] != null) + // We already matched this argument by looking up _indexedAnswers. + continue; + + IEnumerator iterator = YP.unify(arguments[i], answer[i]).GetEnumerator(); + iterators[nIterators++] = iterator; + // MoveNext() is true if YP.unify succeeds. + if (!iterator.MoveNext()) + { + gotMatch = false; + break; + } + } + + try + { + if (gotMatch) + yield return false; + } + finally + { + // Manually finalize all the iterators. + for (int i = 0; i < nIterators; ++i) + iterators[i].Dispose(); + } + } + } + + /// + /// A HashedList extends an ArrayList with methods to get a hash and to check equality + /// based on the elements of the list. + /// + public class HashedList : ArrayList + { + private bool _gotHashCode = false; + private int _hashCode; + + public HashedList() + : base() + { + } + + public HashedList(int capacity) + : base(capacity) + { + } + + public HashedList(ICollection c) + : base(c) + { + } + + // Debug: Should override all the other methods that change this. + public override int Add(object value) + { + _gotHashCode = false; + return base.Add(value); + } + + public override int GetHashCode() + { + if (!_gotHashCode) + { + int hashCode = 1; + foreach (object obj in this) + hashCode = 31 * hashCode + (obj == null ? 0 : obj.GetHashCode()); + _hashCode = hashCode; + _gotHashCode = true; + } + return _hashCode; + } + + public override bool Equals(object obj) + { + if (!(obj is ArrayList)) + return false; + + ArrayList objList = (ArrayList)obj; + if (objList.Count != Count) + return false; + + for (int i = 0; i < Count; ++i) + { + object value = objList[i]; + if (value == null) + { + if (this[i] != null) + return false; + } + else + { + if (!value.Equals(this[i])) + return false; + } + } + return true; + } + } + + /// + /// If we keep an index on value, return the value, or null if we don't index it. + /// + /// the term to examine. Assume you already called YP.getValue(value) + /// + public static object getIndexValue(object value) + { + if (value is Atom || value is string || value is Int32 || value is DateTime) + return value; + else + return null; + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/ListPair.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/ListPair.cs new file mode 100644 index 0000000..83ace2d --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/ListPair.cs @@ -0,0 +1,156 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections.Generic; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + public class ListPair : Functor2 + { + public ListPair(object head, object tail) : base(Atom.DOT, head, tail) + { + } + + public static object make(List list) + { + if (list.Count <= 0) + return Atom.NIL; + + object result = Atom.NIL; + // Start from the end. + for (int i = list.Count - 1; i >= 0; --i) + result = new ListPair(list[i], result); + return result; + } + + public static object make(object[] array) + { + if (array.Length <= 0) + return Atom.NIL; + + object result = Atom.NIL; + // Start from the end. + for (int i = array.Length - 1; i >= 0; --i) + result = new ListPair(array[i], result); + return result; + } + + /// + /// Return a ListPair version of array, where repeated elements + /// (according to YP.termEqual) are removed. + /// + /// + /// + public static object makeWithoutRepeatedTerms(object[] array) + { + if (array.Length <= 0) + return Atom.NIL; + + // Start from the end. + object previousTerm = array[array.Length - 1]; + object result = new ListPair(previousTerm, Atom.NIL); + for (int i = array.Length - 2; i >= 0; --i) + { + object term = array[i]; + if (YP.termEqual(term, previousTerm)) + continue; + result = new ListPair(term, result); + previousTerm = term; + } + return result; + } + + /// + /// Return a ListPair version of array, where repeated elements + /// (according to YP.termEqual) are removed. + /// + /// + /// + public static object makeWithoutRepeatedTerms(List array) + { + if (array.Count <= 0) + return Atom.NIL; + + // Start from the end. + object previousTerm = array[array.Count - 1]; + object result = new ListPair(previousTerm, Atom.NIL); + for (int i = array.Count - 2; i >= 0; --i) + { + object term = array[i]; + if (YP.termEqual(term, previousTerm)) + continue; + result = new ListPair(term, result); + previousTerm = term; + } + return result; + } + + public static object make(object element1) + { + return new ListPair(element1, Atom.NIL); + } + + public static object make(object element1, object element2) + { + return new ListPair(element1, new ListPair(element2, Atom.NIL)); + } + + public static object make(object element1, object element2, object element3) + { + return new ListPair(element1, + new ListPair(element2, new ListPair(element3, Atom.NIL))); + } + + /// + /// Return an array of the elements in list or null if it is not + /// a proper list. If list is Atom.NIL, return an array of zero elements. + /// This does not call YP.getValue on each element. + /// + /// + /// + public static object[] toArray(object list) + { + list = YP.getValue(list); + if (list.Equals(Atom.NIL)) + return new object[0]; + + List result = new List(); + for (object element = list; + element is Functor2 && ((Functor2)element)._name == Atom.DOT; + element = YP.getValue(((Functor2)element)._arg2)) + result.Add(((Functor2)element)._arg1); + + if (result.Count <= 0) + return null; + return result.ToArray(); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs new file mode 100644 index 0000000..105b556 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs @@ -0,0 +1,4457 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections.Generic; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + public class Parser + { + public static IEnumerable formatError(object Output, object Format, object Arguments) + { + // Debug: Simple implementation for now. + YP.write(Format); + YP.write(Arguments); + YP.nl(); + yield return false; + } + + // Debug: Hand-modify this central predicate to do tail recursion. + public static IEnumerable read_tokens(object arg1, object arg2, object arg3) + { + bool repeat = true; + while (repeat) + { + repeat = false; + { + object C1 = arg1; + object Dict = arg2; + object Tokens = arg3; + Variable C2 = new Variable(); + if (YP.lessThanOrEqual(C1, new ListPair(32, Atom.NIL))) + { + if (YP.greaterThanOrEqual(C1, 0)) + { + foreach (bool l4 in YP.get_code(C2)) + { +#if false + foreach (bool l5 in read_tokens(C2, Dict, Tokens)) + { + yield return false; + } +#endif + arg1 = YP.getValue(C2); + arg2 = YP.getValue(Dict); + arg3 = YP.getValue(Tokens); + repeat = true; + } + } + goto cutIf1; + } + if (YP.greaterThanOrEqual(C1, new ListPair(97, Atom.NIL))) + { + if (YP.lessThanOrEqual(C1, new ListPair(122, Atom.NIL))) + { + foreach (bool l4 in read_identifier(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf2; + } + } + if (YP.greaterThanOrEqual(C1, new ListPair(65, Atom.NIL))) + { + if (YP.lessThanOrEqual(C1, new ListPair(90, Atom.NIL))) + { + foreach (bool l4 in read_variable(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf3; + } + } + if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C1, new ListPair(57, Atom.NIL))) + { + foreach (bool l4 in read_number(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf4; + } + } + if (YP.lessThan(C1, 127)) + { + foreach (bool l3 in read_special(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf5; + } + if (YP.lessThanOrEqual(C1, 160)) + { + foreach (bool l3 in YP.get_code(C2)) + { +#if false + foreach (bool l4 in read_tokens(C2, Dict, Tokens)) + { + yield return false; + } +#endif + arg1 = YP.getValue(C2); + arg2 = YP.getValue(Dict); + arg3 = YP.getValue(Tokens); + repeat = true; + } + goto cutIf6; + } + if (YP.greaterThanOrEqual(C1, 223)) + { + if (YP.notEqual(C1, 247)) + { + foreach (bool l4 in read_identifier(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf7; + } + } + if (YP.greaterThanOrEqual(C1, 192)) + { + if (YP.notEqual(C1, 215)) + { + foreach (bool l4 in read_variable(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf8; + } + } + if (YP.notEqual(C1, 170)) + { + if (YP.notEqual(C1, 186)) + { + foreach (bool l4 in read_symbol(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf9; + } + } + foreach (bool l2 in read_identifier(C1, Dict, Tokens)) + { + yield return false; + } + cutIf9: + cutIf8: + cutIf7: + cutIf6: + cutIf5: + cutIf4: + cutIf3: + cutIf2: + cutIf1: + { } + } + } + } + + // Compiler output follows. + + class YPInnerClass { } + static Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; } + + public static IEnumerable parseInput(object TermList) + { + { + Variable TermAndVariables = new Variable(); + FindallAnswers findallAnswers1 = new FindallAnswers(TermAndVariables); + foreach (bool l2 in parseInputHelper(TermAndVariables)) + { + findallAnswers1.add(); + } + foreach (bool l2 in findallAnswers1.result(TermList)) + { + yield return false; + } + } + } + + public static IEnumerable parseInputHelper(object arg1) + { + { + Variable Term = new Variable(); + Variable Variables = new Variable(); + Variable Answer = new Variable(); + Variable x4 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"f", Term, Variables))) + { + foreach (bool l3 in YP.repeat()) + { + foreach (bool l4 in portable_read3(Answer, Variables, x4)) + { + foreach (bool l5 in remove_pos(Answer, Term)) + { + if (YP.termEqual(Term, Atom.a(@"end_of_file"))) + { + yield break; + goto cutIf1; + } + yield return false; + cutIf1: + { } + } + } + } + } + } + } + + public static IEnumerable clear_errors() + { + { + yield return false; + } + } + + public static IEnumerable remove_pos(object arg1, object arg2) + { + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, X)) + { + foreach (bool l3 in YP.unify(arg2, X)) + { + if (YP.var(X)) + { + yield return true; + yield break; + } + } + } + } + { + object X = arg2; + Variable _Pos = new Variable(); + Variable _Name = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"$VAR", _Pos, _Name, X))) + { + if (YP.var(X)) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + Variable H = new Variable(); + Variable T = new Variable(); + Variable NH = new Variable(); + Variable NT = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(H, T))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(NH, NT))) + { + foreach (bool l4 in remove_pos(H, NH)) + { + foreach (bool l5 in remove_pos(T, NT)) + { + yield return false; + } + } + yield break; + } + } + } + { + Variable A = new Variable(); + Variable B = new Variable(); + Variable NA = new Variable(); + Variable NB = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) + { + foreach (bool l3 in YP.unify(arg2, new Functor2(@",", NA, NB))) + { + foreach (bool l4 in remove_pos(A, NA)) + { + foreach (bool l5 in remove_pos(B, NB)) + { + yield return false; + } + } + yield break; + } + } + } + { + Variable Atom_1 = new Variable(); + Variable _F = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom_1)) + { + foreach (bool l3 in YP.unify(arg2, Atom_1)) + { + foreach (bool l4 in YP.functor(Atom_1, _F, 0)) + { + yield return false; + } + } + } + } + { + object Term = arg1; + object NewTerm = arg2; + Variable Func = new Variable(); + Variable _Pos = new Variable(); + Variable Args = new Variable(); + Variable NArgs = new Variable(); + if (YP.nonvar(Term)) + { + foreach (bool l3 in YP.univ(Term, new ListPair(Func, new ListPair(_Pos, Args)))) + { + foreach (bool l4 in remove_pos(Args, NArgs)) + { + foreach (bool l5 in YP.univ(NewTerm, new ListPair(Func, NArgs))) + { + yield return false; + } + } + } + } + } + } + + public static IEnumerable portable_read_position(object Term, object PosTerm, object Syntax) + { + { + foreach (bool l2 in portable_read(PosTerm, Syntax)) + { + foreach (bool l3 in remove_pos(PosTerm, Term)) + { + yield return false; + } + } + } + } + + public static IEnumerable portable_read(object Answer, object Syntax) + { + { + Variable Tokens = new Variable(); + Variable ParseTokens = new Variable(); + foreach (bool l2 in read_tokens1(Tokens)) + { + foreach (bool l3 in remove_comments(Tokens, ParseTokens, Syntax)) + { + foreach (bool l4 in parse2(ParseTokens, Answer)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable portable_read3(object Answer, object Variables, object Syntax) + { + { + Variable Tokens = new Variable(); + Variable ParseTokens = new Variable(); + foreach (bool l2 in read_tokens2(Tokens, Variables)) + { + foreach (bool l3 in remove_comments(Tokens, ParseTokens, Syntax)) + { + foreach (bool l4 in parse2(ParseTokens, Answer)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable remove_comments(object arg1, object arg2, object arg3) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + foreach (bool l4 in YP.unify(arg3, Atom.NIL)) + { + yield return false; + } + } + } + } + { + object Ys = arg2; + Variable S = new Variable(); + Variable E = new Variable(); + Variable Xs = new Variable(); + Variable Zs = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"comment", S, E), Xs))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"comment", S, E), Zs))) + { + foreach (bool l4 in remove_comments(Xs, Ys, Zs)) + { + yield return false; + } + yield break; + } + } + } + { + Variable Pos = new Variable(); + Variable Xs = new Variable(); + Variable Ys = new Variable(); + Variable Pos2 = new Variable(); + Variable Zs = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"/", Atom.a(@"["), Pos), Xs))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"["), Ys))) + { + foreach (bool l4 in YP.unify(arg3, new ListPair(new Functor2(@"list", Pos, Pos2), Zs))) + { + foreach (bool l5 in YP.unify(Pos2, YP.add(Pos, 1))) + { + foreach (bool l6 in remove_comments(Xs, Ys, Zs)) + { + yield return false; + } + } + yield break; + } + } + } + } + { + Variable Pos = new Variable(); + Variable Xs = new Variable(); + Variable Ys = new Variable(); + Variable Pos2 = new Variable(); + Variable Zs = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"/", Atom.a(@"]"), Pos), Xs))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"]"), Ys))) + { + foreach (bool l4 in YP.unify(arg3, new ListPair(new Functor2(@"list", Pos, Pos2), Zs))) + { + foreach (bool l5 in YP.unify(Pos2, YP.add(Pos, 1))) + { + foreach (bool l6 in remove_comments(Xs, Ys, Zs)) + { + yield return false; + } + } + yield break; + } + } + } + } + { + object Zs = arg3; + Variable Token = new Variable(); + Variable Xs = new Variable(); + Variable Ys = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, Xs))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Token, Ys))) + { + foreach (bool l4 in remove_comments(Xs, Ys, Zs)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable expect(object Token, object arg2, object arg3) + { + { + object Rest = arg3; + foreach (bool l2 in YP.unify(arg2, new ListPair(Token, Rest))) + { + yield return true; + yield break; + } + } + { + object S0 = arg2; + object x3 = arg3; + foreach (bool l2 in syntax_error(new ListPair(Token, new ListPair(Atom.a(@"or"), new ListPair(Atom.a(@"operator"), new ListPair(Atom.a(@"expected"), Atom.NIL)))), S0)) + { + yield return false; + } + } + } + + public static IEnumerable parse2(object Tokens, object Answer) + { + { + Variable Term = new Variable(); + Variable LeftOver = new Variable(); + foreach (bool l2 in clear_errors()) + { + foreach (bool l3 in parse(Tokens, 1200, Term, LeftOver)) + { + foreach (bool l4 in all_read(LeftOver)) + { + foreach (bool l5 in YP.unify(Answer, Term)) + { + yield return false; + } + yield break; + } + } + foreach (bool l3 in syntax_error(Tokens)) + { + yield return false; + } + } + } + } + + public static IEnumerable all_read(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + yield return false; + } + } + { + Variable Token = new Variable(); + Variable S = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S))) + { + foreach (bool l3 in syntax_error(new ListPair(Atom.a(@"operator"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"after"), new ListPair(Atom.a(@"expression"), Atom.NIL)))), new ListPair(Token, S))) + { + yield return false; + } + } + } + } + + public static IEnumerable parse(object arg1, object arg2, object arg3, object arg4) + { + { + object x1 = arg2; + object x2 = arg3; + object x3 = arg4; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in syntax_error(new ListPair(Atom.a(@"expression"), new ListPair(Atom.a(@"expected"), Atom.NIL)), Atom.NIL)) + { + yield return false; + } + } + } + { + object Precedence = arg2; + object Term = arg3; + object LeftOver = arg4; + Variable Token = new Variable(); + Variable RestTokens = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, RestTokens))) + { + foreach (bool l3 in parse5(Token, RestTokens, Precedence, Term, LeftOver)) + { + yield return false; + } + } + } + } + + public static IEnumerable parse5(object arg1, object arg2, object arg3, object arg4, object arg5) + { + { + object S0 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"}"))) + { + foreach (bool l3 in cannot_start(Atom.a(@"}"), S0)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) + { + foreach (bool l3 in cannot_start(Atom.a(@"]"), S0)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + foreach (bool l2 in YP.unify(arg1, Atom.a(@")"))) + { + foreach (bool l3 in cannot_start(Atom.a(@")"), S0)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) + { + foreach (bool l3 in cannot_start(Atom.a(@","), S0)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) + { + foreach (bool l3 in cannot_start(Atom.a(@"|"), S0)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Chars = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"string", Chars))) + { + foreach (bool l3 in exprtl0(S0, Chars, Precedence, Answer, S)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Number = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"number", Number))) + { + foreach (bool l3 in exprtl0(S0, Number, Precedence, Answer, S)) + { + yield return false; + } + } + } + { + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"]"), S1))) + { + foreach (bool l4 in read_atom(new Functor2(@"/", Atom.NIL, 0), S1, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + { + object S1 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Arg1 = new Variable(); + Variable S2 = new Variable(); + Variable RestArgs = new Variable(); + Variable S3 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) + { + foreach (bool l3 in parse(S1, 999, Arg1, S2)) + { + foreach (bool l4 in read_list(S2, RestArgs, S3)) + { + foreach (bool l5 in exprtl0(S3, new ListPair(Arg1, RestArgs), Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + } + { + object S1 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Term = new Variable(); + Variable S2 = new Variable(); + Variable S3 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"("))) + { + foreach (bool l3 in parse(S1, 1200, Term, S2)) + { + foreach (bool l4 in expect(Atom.a(@")"), S2, S3)) + { + foreach (bool l5 in exprtl0(S3, Term, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + } + { + object S1 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Term = new Variable(); + Variable S2 = new Variable(); + Variable S3 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@" ("))) + { + foreach (bool l3 in parse(S1, 1200, Term, S2)) + { + foreach (bool l4 in expect(Atom.a(@")"), S2, S3)) + { + foreach (bool l5 in exprtl0(S3, Term, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + } + { + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable _Pos = new Variable(); + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom.a(@"{"), _Pos))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"}"), S1))) + { + foreach (bool l4 in read_atom(Atom.a(@"{}"), S1, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + { + object S1 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Pos = new Variable(); + Variable Term = new Variable(); + Variable S2 = new Variable(); + Variable S3 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom.a(@"{"), Pos))) + { + foreach (bool l3 in parse(S1, 1200, Term, S2)) + { + foreach (bool l4 in expect(Atom.a(@"}"), S2, S3)) + { + foreach (bool l5 in exprtl0(S3, new Functor2(@"{}", Pos, Term), Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + } + { + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Variable_1 = new Variable(); + Variable Name = new Variable(); + Variable Pos = new Variable(); + Variable S1 = new Variable(); + Variable Arg1 = new Variable(); + Variable S2 = new Variable(); + Variable RestArgs = new Variable(); + Variable S3 = new Variable(); + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", Variable_1, Name, Pos))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"("), S1))) + { + foreach (bool l4 in parse(S1, 999, Arg1, S2)) + { + foreach (bool l5 in read_args(S2, RestArgs, S3)) + { + foreach (bool l6 in YP.univ(Term, new ListPair(Atom.a(@"call"), new ListPair(new Functor3(@"$VAR", Pos, Name, Variable_1), new ListPair(Arg1, RestArgs))))) + { + foreach (bool l7 in exprtl0(S3, Term, Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + } + yield break; + } + } + } + { + object S0 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Variable_1 = new Variable(); + Variable Name = new Variable(); + Variable Pos = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", Variable_1, Name, Pos))) + { + foreach (bool l3 in exprtl0(S0, new Functor3(@"$VAR", Pos, Name, Variable_1), Precedence, Answer, S)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Atom_1 = new Variable(); + Variable P = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"atom", Atom_1, P))) + { + foreach (bool l3 in read_atom(new Functor2(@"/", Atom_1, P), S0, Precedence, Answer, S)) + { + yield return false; + } + } + } + } + + public static IEnumerable read_atom(object arg1, object arg2, object Precedence, object Answer, object S) + { + { + Variable _Pos = new Variable(); + Variable Number = new Variable(); + Variable S1 = new Variable(); + Variable Negative = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom.a(@"-"), _Pos))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor1(@"number", Number), S1))) + { + foreach (bool l4 in YP.unify(Negative, YP.negate(Number))) + { + foreach (bool l5 in exprtl0(S1, Negative, Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + } + } + { + Variable Functor_1 = new Variable(); + Variable Pos = new Variable(); + Variable S1 = new Variable(); + Variable Arg1 = new Variable(); + Variable S2 = new Variable(); + Variable RestArgs = new Variable(); + Variable S3 = new Variable(); + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Functor_1, Pos))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"("), S1))) + { + foreach (bool l4 in parse(S1, 999, Arg1, S2)) + { + foreach (bool l5 in read_args(S2, RestArgs, S3)) + { + foreach (bool l6 in YP.univ(Term, new ListPair(Functor_1, new ListPair(Pos, new ListPair(Arg1, RestArgs))))) + { + foreach (bool l7 in exprtl0(S3, Term, Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + } + yield break; + } + } + } + { + object S0 = arg2; + Variable Op = new Variable(); + Variable Pos = new Variable(); + Variable Oprec = new Variable(); + Variable Aprec = new Variable(); + Variable Flag = new Variable(); + Variable Term = new Variable(); + Variable Arg = new Variable(); + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Op, Pos))) + { + foreach (bool l3 in prefixop(Op, Oprec, Aprec)) + { + foreach (bool l4 in possible_right_operand(S0, Flag)) + { + if (YP.lessThan(Flag, 0)) + { + foreach (bool l6 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, Atom.NIL)))) + { + foreach (bool l7 in exprtl0(S0, Term, Precedence, Answer, S)) + { + yield return false; + } + } + goto cutIf1; + } + if (YP.greaterThan(Oprec, Precedence)) + { + foreach (bool l6 in syntax_error(new ListPair(Atom.a(@"prefix"), new ListPair(Atom.a(@"operator"), new ListPair(Op, new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"context"), new ListPair(Atom.a(@"with"), new ListPair(Atom.a(@"precedence"), new ListPair(Precedence, Atom.NIL)))))))), S0)) + { + yield return false; + } + goto cutIf2; + } + if (YP.greaterThan(Flag, 0)) + { + foreach (bool l6 in parse(S0, Aprec, Arg, S1)) + { + foreach (bool l7 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, new ListPair(Arg, Atom.NIL))))) + { + foreach (bool l8 in exprtl(S1, Oprec, Term, Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + goto cutIf3; + } + foreach (bool l5 in peepop(S0, S1)) + { + foreach (bool l6 in prefix_is_atom(S1, Oprec)) + { + foreach (bool l7 in exprtl(S1, Oprec, new Functor2(@"/", Op, Pos), Precedence, Answer, S)) + { + yield return false; + } + } + } + foreach (bool l5 in parse(S0, Aprec, Arg, S1)) + { + foreach (bool l6 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, new ListPair(Arg, Atom.NIL))))) + { + foreach (bool l7 in exprtl(S1, Oprec, Term, Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + cutIf3: + cutIf2: + cutIf1: + { } + } + yield break; + } + } + } + { + object S0 = arg2; + Variable Atom_1 = new Variable(); + Variable Pos = new Variable(); + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom_1, Pos))) + { + foreach (bool l3 in YP.univ(Term, new ListPair(Atom_1, new ListPair(Pos, Atom.NIL)))) + { + foreach (bool l4 in exprtl0(S0, Term, Precedence, Answer, S)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable cannot_start(object Token, object S0) + { + { + foreach (bool l2 in syntax_error(new ListPair(Token, new ListPair(Atom.a(@"cannot"), new ListPair(Atom.a(@"start"), new ListPair(Atom.a(@"an"), new ListPair(Atom.a(@"expression"), Atom.NIL))))), S0)) + { + yield return false; + } + } + } + + public static IEnumerable read_args(object arg1, object arg2, object arg3) + { + { + object S = arg3; + Variable S1 = new Variable(); + Variable Term = new Variable(); + Variable Rest = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@","), S1))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Term, Rest))) + { + foreach (bool l4 in parse(S1, 999, Term, S2)) + { + foreach (bool l5 in read_args(S2, Rest, S)) + { + yield return false; + } + yield break; + } + yield break; + } + } + } + { + object S = arg3; + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@")"), S))) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + object S = arg1; + object x2 = arg2; + object x3 = arg3; + foreach (bool l2 in syntax_error(new ListPair(Atom.a(@", or )"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"arguments"), Atom.NIL)))), S)) + { + yield return false; + } + } + } + + public static IEnumerable read_list(object arg1, object arg2, object arg3) + { + { + object x1 = arg2; + object x2 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in syntax_error(new ListPair(Atom.a(@", | or ]"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"list"), Atom.NIL)))), Atom.NIL)) + { + yield return false; + } + } + } + { + object Rest = arg2; + object S = arg3; + Variable Token = new Variable(); + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S1))) + { + foreach (bool l3 in read_list4(Token, S1, Rest, S)) + { + yield return false; + } + } + } + } + + public static IEnumerable read_list4(object arg1, object arg2, object arg3, object arg4) + { + { + object S1 = arg2; + object S = arg4; + Variable Term = new Variable(); + Variable Rest = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Term, Rest))) + { + foreach (bool l4 in parse(S1, 999, Term, S2)) + { + foreach (bool l5 in read_list(S2, Rest, S)) + { + yield return false; + } + yield break; + } + yield break; + } + } + } + { + object S1 = arg2; + object Rest = arg3; + object S = arg4; + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) + { + foreach (bool l3 in parse(S1, 999, Rest, S2)) + { + foreach (bool l4 in expect(Atom.a(@"]"), S2, S)) + { + yield return false; + } + yield break; + } + yield break; + } + } + { + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) + { + foreach (bool l3 in YP.unify(arg2, S1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.NIL)) + { + foreach (bool l5 in YP.unify(arg4, S1)) + { + yield return true; + yield break; + } + } + } + } + } + { + object Token = arg1; + object S1 = arg2; + object x3 = arg3; + object x4 = arg4; + foreach (bool l2 in syntax_error(new ListPair(Atom.a(@", | or ]"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"list"), Atom.NIL)))), new ListPair(Token, S1))) + { + yield return false; + } + } + } + + public static IEnumerable possible_right_operand(object arg1, object arg2) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + object Flag = arg2; + Variable H = new Variable(); + Variable T = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(H, T))) + { + foreach (bool l3 in possible_right_operand3(H, Flag, T)) + { + yield return false; + } + } + } + } + + public static IEnumerable possible_right_operand3(object arg1, object arg2, object arg3) + { + { + object x4 = arg3; + Variable x1 = new Variable(); + Variable x2 = new Variable(); + Variable x3 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", x1, x2, x3))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + yield return false; + } + } + } + { + object x2 = arg3; + Variable x1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"number", x1))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + yield return false; + } + } + } + { + object x2 = arg3; + Variable x1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"string", x1))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@" ("))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"("))) + { + foreach (bool l3 in YP.unify(arg2, 0)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@")"))) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + Variable x1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) + { + foreach (bool l3 in YP.unify(arg2, 0)) + { + foreach (bool l4 in YP.unify(arg3, new ListPair(Atom.a(@"]"), x1))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + Variable x1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"{"))) + { + foreach (bool l3 in YP.unify(arg2, 0)) + { + foreach (bool l4 in YP.unify(arg3, new ListPair(Atom.a(@"}"), x1))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"{"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"}"))) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + object x3 = arg3; + Variable x1 = new Variable(); + Variable x2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"atom", x1, x2))) + { + foreach (bool l3 in YP.unify(arg2, 0)) + { + yield return false; + } + } + } + } + + public static IEnumerable peepop(object arg1, object arg2) + { + { + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", F, Pos), new ListPair(Atom.a(@"("), S1)))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor2(@"atom", F, Pos), new ListPair(Atom.a(@"("), S1)))) + { + yield return true; + yield break; + } + } + } + { + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable S1 = new Variable(); + Variable L = new Variable(); + Variable P = new Variable(); + Variable R = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", F, Pos), S1))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L, P, R }), S1))) + { + foreach (bool l4 in infixop(F, L, P, R)) + { + yield return false; + } + } + } + } + { + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable S1 = new Variable(); + Variable L = new Variable(); + Variable P = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", F, Pos), S1))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L, P), S1))) + { + foreach (bool l4 in postfixop(F, L, P)) + { + yield return false; + } + } + } + } + { + Variable S0 = new Variable(); + foreach (bool l2 in YP.unify(arg1, S0)) + { + foreach (bool l3 in YP.unify(arg2, S0)) + { + yield return false; + } + } + } + } + + public static IEnumerable prefix_is_atom(object arg1, object arg2) + { + { + object Precedence = arg2; + Variable Token = new Variable(); + Variable x2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, x2))) + { + foreach (bool l3 in prefix_is_atom(Token, Precedence)) + { + yield return false; + } + } + } + { + object P = arg2; + Variable x1 = new Variable(); + Variable L = new Variable(); + Variable x3 = new Variable(); + Variable x4 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { x1, L, x3, x4 }))) + { + if (YP.greaterThanOrEqual(L, P)) + { + yield return false; + } + } + } + { + object P = arg2; + Variable x1 = new Variable(); + Variable L = new Variable(); + Variable x3 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(Atom.a(@"postfixop", Atom.a(@"")), x1, L, x3))) + { + if (YP.greaterThanOrEqual(L, P)) + { + yield return false; + } + } + } + { + object x1 = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@")"))) + { + yield return false; + } + } + { + object x1 = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) + { + yield return false; + } + } + { + object x1 = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"}"))) + { + yield return false; + } + } + { + object P = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) + { + if (YP.greaterThanOrEqual(1100, P)) + { + yield return false; + } + } + } + { + object P = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) + { + if (YP.greaterThanOrEqual(1000, P)) + { + yield return false; + } + } + } + { + object x1 = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + yield return false; + } + } + } + + public static IEnumerable exprtl0(object arg1, object arg2, object arg3, object arg4, object arg5) + { + { + object x2 = arg3; + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, Term)) + { + foreach (bool l4 in YP.unify(arg4, Term)) + { + foreach (bool l5 in YP.unify(arg5, Atom.NIL)) + { + yield return false; + } + } + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Token = new Variable(); + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S1))) + { + foreach (bool l3 in exprtl0_6(Token, Term, Precedence, Answer, S, S1)) + { + yield return false; + } + } + } + } + + public static IEnumerable exprtl0_6(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) + { + { + object x2 = arg3; + object S1 = arg6; + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"}"))) + { + foreach (bool l3 in YP.unify(arg2, Term)) + { + foreach (bool l4 in YP.unify(arg4, Term)) + { + foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(@"}"), S1))) + { + yield return false; + } + } + } + } + } + { + object x2 = arg3; + object S1 = arg6; + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) + { + foreach (bool l3 in YP.unify(arg2, Term)) + { + foreach (bool l4 in YP.unify(arg4, Term)) + { + foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(@"]"), S1))) + { + yield return false; + } + } + } + } + } + { + object x2 = arg3; + object S1 = arg6; + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@")"))) + { + foreach (bool l3 in YP.unify(arg2, Term)) + { + foreach (bool l4 in YP.unify(arg4, Term)) + { + foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(@")"), S1))) + { + yield return false; + } + } + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + object S1 = arg6; + Variable Next = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) + { + if (YP.greaterThanOrEqual(Precedence, 1000)) + { + foreach (bool l4 in parse(S1, 1000, Next, S2)) + { + foreach (bool l5 in exprtl(S2, 1000, new Functor2(@",", Term, Next), Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + goto cutIf1; + } + foreach (bool l3 in YP.unify(Answer, Term)) + { + foreach (bool l4 in YP.unify(S, new ListPair(Atom.a(@","), S1))) + { + yield return false; + } + } + cutIf1: + { } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + object S1 = arg6; + Variable Next = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) + { + if (YP.greaterThanOrEqual(Precedence, 1100)) + { + foreach (bool l4 in parse(S1, 1100, Next, S2)) + { + foreach (bool l5 in exprtl(S2, 1100, new Functor2(@";", Term, Next), Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + goto cutIf2; + } + foreach (bool l3 in YP.unify(Answer, Term)) + { + foreach (bool l4 in YP.unify(S, new ListPair(Atom.a(@"|"), S1))) + { + yield return false; + } + } + cutIf2: + { } + } + } + { + object x2 = arg2; + object x3 = arg3; + object x4 = arg4; + object x5 = arg5; + object S1 = arg6; + Variable S = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"string", S))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"chars"), new Functor1(@"string", S), S1)) + { + yield return false; + } + } + } + { + object x2 = arg2; + object x3 = arg3; + object x4 = arg4; + object x5 = arg5; + object S1 = arg6; + Variable N = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"number", N))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"number"), new Functor1(@"number", N), S1)) + { + yield return false; + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"{"))) + { + foreach (bool l3 in YP.unify(arg6, new ListPair(Atom.a(@"}"), S1))) + { + foreach (bool l4 in exprtl0_atom(Atom.a(@"{}"), Term, Precedence, Answer, S, S1)) + { + yield return false; + } + yield break; + } + } + } + { + object x1 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + object S1 = arg6; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"{"))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"brace"), Atom.a(@"{"), S1)) + { + yield return false; + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) + { + foreach (bool l3 in YP.unify(arg6, new ListPair(Atom.a(@"]"), S1))) + { + foreach (bool l4 in exprtl0_atom(Atom.NIL, Term, Precedence, Answer, S, S1)) + { + yield return false; + } + yield break; + } + } + } + { + object x1 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + object S1 = arg6; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"bracket"), Atom.a(@"["), S1)) + { + yield return false; + } + } + } + { + object x1 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + object S1 = arg6; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"("))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"parenthesis"), Atom.a(@"("), S1)) + { + yield return false; + } + } + } + { + object x1 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + object S1 = arg6; + foreach (bool l2 in YP.unify(arg1, Atom.a(@" ("))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"parenthesis"), Atom.a(@"("), S1)) + { + yield return false; + } + } + } + { + object x4 = arg2; + object x5 = arg3; + object x6 = arg4; + object x7 = arg5; + object S1 = arg6; + Variable A = new Variable(); + Variable B = new Variable(); + Variable P = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", A, B, P))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"variable"), new Functor3(@"var", A, B, P), S1)) + { + yield return false; + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + object S1 = arg6; + Variable F = new Variable(); + Variable P = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"atom", F, P))) + { + foreach (bool l3 in exprtl0_atom(new Functor2(@"/", F, P), Term, Precedence, Answer, S, S1)) + { + yield return false; + } + } + } + } + + public static IEnumerable exprtl0_atom(object arg1, object arg2, object arg3, object arg4, object arg5, object S1) + { + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable L1 = new Variable(); + Variable O1 = new Variable(); + Variable R1 = new Variable(); + Variable L2 = new Variable(); + Variable O2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", F, Pos))) + { + foreach (bool l3 in ambigop(F, Precedence, L1, O1, R1, L2, O2)) + { + foreach (bool l4 in prefix_is_atom(S1, Precedence)) + { + foreach (bool l5 in exprtl(new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + foreach (bool l4 in exprtl(new ListPair(new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L1, O1, R1 }), S1), 0, Term, Precedence, Answer, S)) + { + yield return false; + } + foreach (bool l4 in exprtl(new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable L1 = new Variable(); + Variable O1 = new Variable(); + Variable R1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", F, Pos))) + { + foreach (bool l3 in infixop(F, L1, O1, R1)) + { + foreach (bool l4 in exprtl(new ListPair(new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L1, O1, R1 }), S1), 0, Term, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable L2 = new Variable(); + Variable O2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", F, Pos))) + { + foreach (bool l3 in postfixop(F, L2, O2)) + { + foreach (bool l4 in exprtl(new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + { + object X = arg1; + object x2 = arg2; + object x3 = arg3; + object x4 = arg4; + object x5 = arg5; + Variable x7 = new Variable(); + foreach (bool l2 in syntax_error(new ListPair(new Functor2(@"-", Atom.a(@"non"), Atom.a(@"operator")), new ListPair(X, new ListPair(Atom.a(@"follows"), new ListPair(Atom.a(@"expression"), Atom.NIL)))), new ListPair(new Functor2(@"atom", X, x7), S1))) + { + yield return false; + } + yield break; + } + } + + public static IEnumerable cannot_follow(object Type, object Token, object Tokens) + { + { + foreach (bool l2 in syntax_error(new ListPair(Type, new ListPair(Atom.a(@"follows"), new ListPair(Atom.a(@"expression"), Atom.NIL))), new ListPair(Token, Tokens))) + { + yield return false; + } + } + } + + public static IEnumerable exprtl(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) + { + { + object x1 = arg2; + object x3 = arg4; + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg3, Term)) + { + foreach (bool l4 in YP.unify(arg5, Term)) + { + foreach (bool l5 in YP.unify(arg6, Atom.NIL)) + { + yield return false; + } + } + } + } + } + { + object C = arg2; + object Term = arg3; + object Precedence = arg4; + object Answer = arg5; + object S = arg6; + Variable Token = new Variable(); + Variable Tokens = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, Tokens))) + { + foreach (bool l3 in exprtl_7(Token, C, Term, Precedence, Answer, S, Tokens)) + { + yield return false; + } + } + } + } + + public static IEnumerable exprtl_7(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6, object arg7) + { + { + object C = arg2; + object Term = arg3; + object Precedence = arg4; + object Answer = arg5; + object S = arg6; + object S1 = arg7; + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable L = new Variable(); + Variable O = new Variable(); + Variable R = new Variable(); + Variable Other = new Variable(); + Variable S2 = new Variable(); + Variable Expr = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L, O, R }))) + { + if (YP.greaterThanOrEqual(Precedence, O)) + { + if (YP.lessThanOrEqual(C, L)) + { + foreach (bool l5 in parse(S1, R, Other, S2)) + { + foreach (bool l6 in YP.univ(Expr, new ListPair(F, new ListPair(Pos, new ListPair(Term, new ListPair(Other, Atom.NIL)))))) + { + foreach (bool l7 in exprtl(S2, O, Expr, Precedence, Answer, S)) + { + yield return false; + } + } + } + yield break; + } + } + } + } + { + object C = arg2; + object Term = arg3; + object Precedence = arg4; + object Answer = arg5; + object S = arg6; + object S1 = arg7; + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable L = new Variable(); + Variable O = new Variable(); + Variable Expr = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L, O))) + { + if (YP.greaterThanOrEqual(Precedence, O)) + { + if (YP.lessThanOrEqual(C, L)) + { + foreach (bool l5 in YP.univ(Expr, new ListPair(F, new ListPair(Pos, new ListPair(Term, Atom.NIL))))) + { + foreach (bool l6 in peepop(S1, S2)) + { + foreach (bool l7 in exprtl(S2, O, Expr, Precedence, Answer, S)) + { + yield return false; + } + } + } + yield break; + } + } + } + } + { + object C = arg2; + object Term = arg3; + object Precedence = arg4; + object Answer = arg5; + object S = arg6; + object S1 = arg7; + Variable Next = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) + { + if (YP.greaterThanOrEqual(Precedence, 1000)) + { + if (YP.lessThan(C, 1000)) + { + foreach (bool l5 in parse(S1, 1000, Next, S2)) + { + foreach (bool l6 in exprtl(S2, 1000, new Functor2(@",", Term, Next), Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + } + } + } + { + object C = arg2; + object Term = arg3; + object Precedence = arg4; + object Answer = arg5; + object S = arg6; + object S1 = arg7; + Variable Next = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) + { + if (YP.greaterThanOrEqual(Precedence, 1100)) + { + if (YP.lessThan(C, 1100)) + { + foreach (bool l5 in parse(S1, 1100, Next, S2)) + { + foreach (bool l6 in exprtl(S2, 1100, new Functor2(@";", Term, Next), Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + } + } + } + { + object Token = arg1; + object x2 = arg2; + object x4 = arg4; + object Tokens = arg7; + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg3, Term)) + { + foreach (bool l3 in YP.unify(arg5, Term)) + { + foreach (bool l4 in YP.unify(arg6, new ListPair(Token, Tokens))) + { + yield return false; + } + } + } + } + } + + public static IEnumerable syntax_error(object _Message, object _List) + { + { + yield break; + } + } + + public static IEnumerable syntax_error(object _List) + { + { + yield break; + } + } + + public static IEnumerable prefixop(object F, object O, object Q) + { + { + foreach (bool l2 in YP.current_op(O, Atom.a(@"fx"), F)) + { + foreach (bool l3 in YP.unify(Q, YP.subtract(O, 1))) + { + yield return false; + } + goto cutIf1; + } + foreach (bool l2 in YP.current_op(O, Atom.a(@"fy"), F)) + { + foreach (bool l3 in YP.unify(Q, O)) + { + yield return false; + } + goto cutIf2; + } + cutIf2: + cutIf1: + { } + } + } + + public static IEnumerable postfixop(object F, object P, object O) + { + { + foreach (bool l2 in YP.current_op(O, Atom.a(@"xf"), F)) + { + foreach (bool l3 in YP.unify(P, YP.subtract(O, 1))) + { + yield return false; + } + goto cutIf1; + } + foreach (bool l2 in YP.current_op(O, Atom.a(@"yf"), F)) + { + foreach (bool l3 in YP.unify(P, O)) + { + yield return false; + } + goto cutIf2; + } + cutIf2: + cutIf1: + { } + } + } + + public static IEnumerable infixop(object F, object P, object O, object Q) + { + { + foreach (bool l2 in YP.current_op(O, Atom.a(@"xfy"), F)) + { + foreach (bool l3 in YP.unify(P, YP.subtract(O, 1))) + { + foreach (bool l4 in YP.unify(Q, O)) + { + yield return false; + } + } + goto cutIf1; + } + foreach (bool l2 in YP.current_op(O, Atom.a(@"xfx"), F)) + { + foreach (bool l3 in YP.unify(P, YP.subtract(O, 1))) + { + foreach (bool l4 in YP.unify(Q, P)) + { + yield return false; + } + } + goto cutIf2; + } + foreach (bool l2 in YP.current_op(O, Atom.a(@"yfx"), F)) + { + foreach (bool l3 in YP.unify(Q, YP.subtract(O, 1))) + { + foreach (bool l4 in YP.unify(P, O)) + { + yield return false; + } + } + goto cutIf3; + } + cutIf3: + cutIf2: + cutIf1: + { } + } + } + + public static IEnumerable ambigop(object F, object Precedence, object L1, object O1, object R1, object L2, object O2) + { + { + foreach (bool l2 in postfixop(F, L2, O2)) + { + if (YP.lessThanOrEqual(O2, Precedence)) + { + foreach (bool l4 in infixop(F, L1, O1, R1)) + { + if (YP.lessThanOrEqual(O1, Precedence)) + { + yield return false; + } + } + } + } + } + } + + public static IEnumerable read_tokens1(object arg1) + { + { + object TokenList = arg1; + Variable C1 = new Variable(); + Variable _X = new Variable(); + Variable ListOfTokens = new Variable(); + foreach (bool l2 in YP.get_code(C1)) + { + foreach (bool l3 in read_tokens(C1, _X, ListOfTokens)) + { + foreach (bool l4 in YP.unify(TokenList, ListOfTokens)) + { + yield return false; + } + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", Atom.a(@"end_of_file"), 0), Atom.NIL))) + { + yield return false; + } + } + } + + public static IEnumerable read_tokens2(object arg1, object arg2) + { + { + object TokenList = arg1; + object Dictionary = arg2; + Variable C1 = new Variable(); + Variable Dict = new Variable(); + Variable ListOfTokens = new Variable(); + foreach (bool l2 in YP.get_code(C1)) + { + foreach (bool l3 in read_tokens(C1, Dict, ListOfTokens)) + { + foreach (bool l4 in terminate_list(Dict)) + { + foreach (bool l5 in YP.unify(Dictionary, Dict)) + { + foreach (bool l6 in YP.unify(TokenList, ListOfTokens)) + { + yield return false; + } + } + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", Atom.a(@"end_of_file"), 0), Atom.NIL))) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + yield return false; + } + } + } + } + + public static IEnumerable terminate_list(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + yield return false; + } + } + { + Variable x1 = new Variable(); + Variable Tail = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(x1, Tail))) + { + foreach (bool l3 in terminate_list(Tail)) + { + yield return false; + } + } + } + } + + public static IEnumerable read_special(object arg1, object Dict, object arg3) + { + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 95)) + { + foreach (bool l3 in read_variable(95, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 247)) + { + foreach (bool l3 in read_symbol(247, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 215)) + { + foreach (bool l3 in read_symbol(215, Dict, Tokens)) + { + yield return false; + } + } + } + { + Variable StartPos = new Variable(); + Variable EndPos = new Variable(); + Variable Tokens = new Variable(); + Variable Ch = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 37)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"comment", StartPos, EndPos), Tokens))) + { + foreach (bool l4 in get_current_position(StartPos)) + { + foreach (bool l5 in YP.repeat()) + { + foreach (bool l6 in YP.get_code(Ch)) + { + if (YP.lessThan(Ch, new ListPair(32, Atom.NIL))) + { + if (YP.notEqual(Ch, 9)) + { + if (YP.termNotEqual(Ch, -1)) + { + foreach (bool l10 in get_current_position(EndPos)) + { + foreach (bool l11 in YP.get_code(NextCh)) + { + foreach (bool l12 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + yield break; + } + } + } + } + } + } + } + } + { + object T = arg3; + Variable C2 = new Variable(); + Variable StartPos = new Variable(); + Variable EndPos = new Variable(); + Variable Tokens = new Variable(); + Variable StartPos1 = new Variable(); + Variable NextCh = new Variable(); + Variable Chars = new Variable(); + foreach (bool l2 in YP.unify(arg1, 47)) + { + foreach (bool l3 in YP.get_code(C2)) + { + if (YP.equal(C2, new ListPair(42, Atom.NIL))) + { + foreach (bool l5 in YP.unify(T, new ListPair(new Functor2(@"comment", StartPos, EndPos), Tokens))) + { + foreach (bool l6 in get_current_position(StartPos1)) + { + foreach (bool l7 in YP.unify(StartPos, YP.subtract(StartPos1, 1))) + { + foreach (bool l8 in read_solidus(32, NextCh)) + { + foreach (bool l9 in get_current_position(EndPos)) + { + foreach (bool l10 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + goto cutIf1; + } + foreach (bool l4 in YP.unify(T, Tokens)) + { + foreach (bool l5 in rest_symbol(C2, Chars, NextCh)) + { + foreach (bool l6 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(47, Chars))) + { + yield return false; + } + } + } + cutIf1: + { } + } + } + } + { + Variable Pos = new Variable(); + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 33)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"atom", Atom.a(@"!"), Pos), Tokens))) + { + foreach (bool l4 in get_current_position(Pos)) + { + foreach (bool l5 in YP.get_code(NextCh)) + { + foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + { + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 40)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@" ("), Tokens))) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + { + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 41)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@")"), Tokens))) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + { + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 44)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@","), Tokens))) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + { + Variable Pos = new Variable(); + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 59)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"atom", Atom.a(@";"), Pos), Tokens))) + { + foreach (bool l4 in get_current_position(Pos)) + { + foreach (bool l5 in YP.get_code(NextCh)) + { + foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + { + Variable Pos = new Variable(); + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 91)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"/", Atom.a(@"["), Pos), Tokens))) + { + foreach (bool l4 in get_current_position(Pos)) + { + foreach (bool l5 in YP.get_code(NextCh)) + { + foreach (bool l6 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + { + Variable Pos = new Variable(); + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 93)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"/", Atom.a(@"]"), Pos), Tokens))) + { + foreach (bool l4 in get_current_position(Pos)) + { + foreach (bool l5 in YP.get_code(NextCh)) + { + foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + { + Variable Pos = new Variable(); + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 123)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"/", Atom.a(@"{"), Pos), Tokens))) + { + foreach (bool l4 in get_current_position(Pos)) + { + foreach (bool l5 in YP.get_code(NextCh)) + { + foreach (bool l6 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + { + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 124)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"|"), Tokens))) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + { + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 125)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"}"), Tokens))) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in read_after_atom(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + { + object Tokens = arg3; + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 46)) + { + foreach (bool l3 in YP.get_code(NextCh)) + { + foreach (bool l4 in read_fullstop(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + { + Variable Chars = new Variable(); + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 34)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1(@"string", Chars), Tokens))) + { + foreach (bool l4 in read_string(Chars, 34, NextCh)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + { + object Tokens = arg3; + Variable Chars = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 39)) + { + foreach (bool l3 in read_string(Chars, 39, NextCh)) + { + foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, Chars)) + { + yield return false; + } + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 35)) + { + foreach (bool l3 in read_symbol(35, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 36)) + { + foreach (bool l3 in read_symbol(36, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 38)) + { + foreach (bool l3 in read_symbol(38, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 42)) + { + foreach (bool l3 in read_symbol(42, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 43)) + { + foreach (bool l3 in read_symbol(43, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 45)) + { + foreach (bool l3 in read_symbol(45, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 58)) + { + foreach (bool l3 in read_symbol(58, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 60)) + { + foreach (bool l3 in read_symbol(60, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 61)) + { + foreach (bool l3 in read_symbol(61, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 62)) + { + foreach (bool l3 in read_symbol(62, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 63)) + { + foreach (bool l3 in read_symbol(63, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 64)) + { + foreach (bool l3 in read_symbol(64, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 92)) + { + foreach (bool l3 in read_symbol(92, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 94)) + { + foreach (bool l3 in read_symbol(94, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 96)) + { + foreach (bool l3 in read_symbol(96, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 126)) + { + foreach (bool l3 in read_symbol(126, Dict, Tokens)) + { + yield return false; + } + } + } + } + + public static IEnumerable read_symbol(object C1, object Dict, object Tokens) + { + { + Variable C2 = new Variable(); + Variable Chars = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.get_code(C2)) + { + foreach (bool l3 in rest_symbol(C2, Chars, NextCh)) + { + foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(C1, Chars))) + { + yield return false; + } + } + } + } + } + + public static IEnumerable rest_symbol(object arg1, object arg2, object arg3) + { + { + object C2 = arg1; + object LastCh = arg3; + Variable Chars = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(C2, Chars))) + { + if (YP.greaterThan(C2, 160)) + { + if (YP.lessThan(C2, 192)) + { + if (YP.notEqual(C2, 186)) + { + if (YP.notEqual(C2, 170)) + { + foreach (bool l7 in YP.get_code(NextCh)) + { + foreach (bool l8 in rest_symbol(NextCh, Chars, LastCh)) + { + yield return false; + } + } + yield break; + } + } + } + goto cutIf1; + } + foreach (bool l3 in symbol_char(C2)) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in rest_symbol(NextCh, Chars, LastCh)) + { + yield return false; + } + } + yield break; + } + cutIf1: + { } + } + } + { + Variable C2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, C2)) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + foreach (bool l4 in YP.unify(arg3, C2)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable symbol_char(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, 35)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 36)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 38)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 42)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 43)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 45)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 46)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 47)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 58)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 60)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 61)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 62)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 63)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 64)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 92)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 94)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 96)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 126)) + { + yield return false; + } + } + } + + public static IEnumerable get_current_position(object Pos) + { + { + foreach (bool l2 in YP.unify(Pos, 0)) + { + yield return false; + } + } + } + + public static IEnumerable read_after_atom4(object Ch, object Dict, object arg3, object Chars) + { + { + Variable Atom_1 = new Variable(); + Variable Pos = new Variable(); + Variable Tokens = new Variable(); + foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor2(@"atom", Atom_1, Pos), Tokens))) + { + foreach (bool l3 in YP.unify(Pos, 0)) + { + foreach (bool l4 in YP.atom_codes(Atom_1, Chars)) + { + foreach (bool l5 in read_after_atom(Ch, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + + public static IEnumerable read_after_atom(object arg1, object Dict, object arg3) + { + { + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 40)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"("), Tokens))) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + yield break; + } + } + } + { + object Ch = arg1; + object Tokens = arg3; + foreach (bool l2 in read_tokens(Ch, Dict, Tokens)) + { + yield return false; + } + } + } + + public static IEnumerable read_string(object Chars, object Quote, object NextCh) + { + { + Variable Ch = new Variable(); + Variable Char = new Variable(); + Variable Next = new Variable(); + foreach (bool l2 in YP.get_code(Ch)) + { + foreach (bool l3 in read_char(Ch, Quote, Char, Next)) + { + foreach (bool l4 in rest_string5(Char, Next, Chars, Quote, NextCh)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable rest_string5(object arg1, object arg2, object arg3, object arg4, object arg5) + { + { + object _X = arg4; + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, -1)) + { + foreach (bool l3 in YP.unify(arg2, NextCh)) + { + foreach (bool l4 in YP.unify(arg3, Atom.NIL)) + { + foreach (bool l5 in YP.unify(arg5, NextCh)) + { + yield return true; + yield break; + } + } + } + } + } + { + object Char = arg1; + object Next = arg2; + object Quote = arg4; + object NextCh = arg5; + Variable Chars = new Variable(); + Variable Char2 = new Variable(); + Variable Next2 = new Variable(); + foreach (bool l2 in YP.unify(arg3, new ListPair(Char, Chars))) + { + foreach (bool l3 in read_char(Next, Quote, Char2, Next2)) + { + foreach (bool l4 in rest_string5(Char2, Next2, Chars, Quote, NextCh)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable escape_char(object arg1, object arg2) + { + { + foreach (bool l2 in YP.unify(arg1, 110)) + { + foreach (bool l3 in YP.unify(arg2, 10)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 78)) + { + foreach (bool l3 in YP.unify(arg2, 10)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 116)) + { + foreach (bool l3 in YP.unify(arg2, 9)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 84)) + { + foreach (bool l3 in YP.unify(arg2, 9)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 114)) + { + foreach (bool l3 in YP.unify(arg2, 13)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 82)) + { + foreach (bool l3 in YP.unify(arg2, 13)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 118)) + { + foreach (bool l3 in YP.unify(arg2, 11)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 86)) + { + foreach (bool l3 in YP.unify(arg2, 11)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 98)) + { + foreach (bool l3 in YP.unify(arg2, 8)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 66)) + { + foreach (bool l3 in YP.unify(arg2, 8)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 102)) + { + foreach (bool l3 in YP.unify(arg2, 12)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 70)) + { + foreach (bool l3 in YP.unify(arg2, 12)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 101)) + { + foreach (bool l3 in YP.unify(arg2, 27)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 69)) + { + foreach (bool l3 in YP.unify(arg2, 27)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 100)) + { + foreach (bool l3 in YP.unify(arg2, 127)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 68)) + { + foreach (bool l3 in YP.unify(arg2, 127)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 115)) + { + foreach (bool l3 in YP.unify(arg2, 32)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 83)) + { + foreach (bool l3 in YP.unify(arg2, 32)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 122)) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 90)) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + } + + public static IEnumerable read_variable(object C1, object Dict, object arg3) + { + { + Variable Var = new Variable(); + Variable Name = new Variable(); + Variable StartPos = new Variable(); + Variable Tokens = new Variable(); + Variable Chars = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor3(@"var", Var, Name, StartPos), Tokens))) + { + foreach (bool l3 in get_current_position(StartPos)) + { + foreach (bool l4 in read_name(C1, Chars, NextCh)) + { + foreach (bool l5 in YP.atom_codes(Name, Chars)) + { + if (YP.termEqual(Name, Atom.a(@"_"))) + { + foreach (bool l7 in read_after_atom(NextCh, Dict, Tokens)) + { + yield return false; + } + goto cutIf1; + } + foreach (bool l6 in read_lookup(Dict, Name, Var)) + { + foreach (bool l7 in read_after_atom(NextCh, Dict, Tokens)) + { + yield return false; + } + } + cutIf1: + { } + } + } + } + } + } + } + + public static IEnumerable read_lookup(object arg1, object Name, object Var) + { + { + Variable N = new Variable(); + Variable V = new Variable(); + Variable L = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"=", N, V), L))) + { + foreach (bool l3 in YP.unify(N, Name)) + { + foreach (bool l4 in YP.unify(V, Var)) + { + yield return false; + } + goto cutIf1; + } + foreach (bool l3 in read_lookup(L, Name, Var)) + { + yield return false; + } + cutIf1: + { } + } + } + } + + public static IEnumerable read_solidus(object Ch, object LastCh) + { + { + Variable NextCh = new Variable(); + if (YP.equal(Ch, 42)) + { + foreach (bool l3 in YP.get_code(NextCh)) + { + if (YP.equal(NextCh, 47)) + { + foreach (bool l5 in YP.get_code(LastCh)) + { + yield return false; + } + goto cutIf2; + } + foreach (bool l4 in read_solidus(NextCh, LastCh)) + { + yield return false; + } + cutIf2: + { } + } + goto cutIf1; + } + if (YP.notEqual(Ch, -1)) + { + foreach (bool l3 in YP.get_code(NextCh)) + { + foreach (bool l4 in read_solidus(NextCh, LastCh)) + { + yield return false; + } + } + goto cutIf3; + } + foreach (bool l2 in YP.unify(LastCh, Ch)) + { + foreach (bool l3 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file in /*comment~n"), Atom.NIL)) + { + yield return false; + } + } + cutIf3: + cutIf1: + { } + } + } + + public static IEnumerable read_identifier(object C1, object Dict, object Tokens) + { + { + Variable Chars = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in read_name(C1, Chars, NextCh)) + { + foreach (bool l3 in read_after_atom4(NextCh, Dict, Tokens, Chars)) + { + yield return false; + } + } + } + } + + public static IEnumerable read_name(object C1, object arg2, object LastCh) + { + { + Variable Chars = new Variable(); + Variable C2 = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars))) + { + foreach (bool l3 in YP.get_code(C2)) + { + if (YP.greaterThanOrEqual(C2, new ListPair(97, Atom.NIL))) + { + if (YP.lessThanOrEqual(C2, new ListPair(122, Atom.NIL))) + { + foreach (bool l6 in read_name(C2, Chars, LastCh)) + { + yield return false; + } + goto cutIf2; + } + if (YP.lessThan(C2, 192)) + { + if (YP.notEqual(YP.bitwiseOr(C2, 16), 186)) + { + foreach (bool l7 in YP.unify(Chars, Atom.NIL)) + { + foreach (bool l8 in YP.unify(LastCh, C2)) + { + yield return false; + } + } + goto cutIf3; + } + } + if (YP.equal(YP.bitwiseOr(C2, 32), 247)) + { + foreach (bool l6 in YP.unify(Chars, Atom.NIL)) + { + foreach (bool l7 in YP.unify(LastCh, C2)) + { + yield return false; + } + } + goto cutIf4; + } + foreach (bool l5 in read_name(C2, Chars, LastCh)) + { + yield return false; + } + cutIf4: + cutIf3: + cutIf2: + goto cutIf1; + } + if (YP.greaterThanOrEqual(C2, new ListPair(65, Atom.NIL))) + { + if (YP.greaterThan(C2, new ListPair(90, Atom.NIL))) + { + if (YP.notEqual(C2, new ListPair(95, Atom.NIL))) + { + foreach (bool l7 in YP.unify(Chars, Atom.NIL)) + { + foreach (bool l8 in YP.unify(LastCh, C2)) + { + yield return false; + } + } + goto cutIf6; + } + } + foreach (bool l5 in read_name(C2, Chars, LastCh)) + { + yield return false; + } + cutIf6: + goto cutIf5; + } + if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL))) + { + foreach (bool l6 in read_name(C2, Chars, LastCh)) + { + yield return false; + } + goto cutIf7; + } + } + foreach (bool l4 in YP.unify(Chars, Atom.NIL)) + { + foreach (bool l5 in YP.unify(LastCh, C2)) + { + yield return false; + } + } + cutIf7: + cutIf5: + cutIf1: + { } + } + } + } + } + + public static IEnumerable read_fullstop(object Ch, object Dict, object Tokens) + { + { + Variable Number = new Variable(); + Variable Tokens1 = new Variable(); + Variable Chars = new Variable(); + Variable NextCh = new Variable(); + if (YP.lessThanOrEqual(Ch, new ListPair(57, Atom.NIL))) + { + if (YP.greaterThanOrEqual(Ch, new ListPair(48, Atom.NIL))) + { + foreach (bool l4 in YP.unify(Tokens, new ListPair(new Functor1(@"number", Number), Tokens1))) + { + foreach (bool l5 in read_float(Number, Dict, Tokens1, new ListPair(48, Atom.NIL), Ch)) + { + yield return false; + } + } + goto cutIf1; + } + } + if (YP.greaterThan(Ch, new ListPair(32, Atom.NIL))) + { + foreach (bool l3 in rest_symbol(Ch, Chars, NextCh)) + { + foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(46, Chars))) + { + yield return false; + } + } + goto cutIf2; + } + if (YP.greaterThanOrEqual(Ch, 0)) + { + foreach (bool l3 in YP.unify(Tokens, Atom.NIL)) + { + yield return false; + } + goto cutIf3; + } + foreach (bool l2 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file just after full stop~n"), Atom.NIL)) + { + } + cutIf3: + cutIf2: + cutIf1: + { } + } + } + + public static IEnumerable read_float(object Number, object Dict, object Tokens, object Digits, object Digit) + { + { + Variable Chars = new Variable(); + Variable Rest = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in prepend(Digits, Chars, Rest)) + { + foreach (bool l3 in read_float(Digit, Rest, NextCh, Chars)) + { + foreach (bool l4 in YP.number_codes(Number, Chars)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + + public static IEnumerable prepend(object arg1, object arg2, object arg3) + { + { + object X = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(46, X))) + { + yield return false; + } + } + } + { + object Y = arg3; + Variable C = new Variable(); + Variable Cs = new Variable(); + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(C, Cs))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(C, X))) + { + foreach (bool l4 in prepend(Cs, X, Y)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable read_float(object C1, object arg2, object NextCh, object Total) + { + { + Variable Chars = new Variable(); + Variable C2 = new Variable(); + Variable C3 = new Variable(); + Variable C4 = new Variable(); + Variable More = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars))) + { + foreach (bool l3 in YP.get_code(C2)) + { + if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL))) + { + foreach (bool l6 in read_float(C2, Chars, NextCh, Total)) + { + yield return false; + } + goto cutIf1; + } + } + if (YP.equal(YP.bitwiseOr(C2, 32), new ListPair(101, Atom.NIL))) + { + foreach (bool l5 in YP.get_code(C3)) + { + if (YP.equal(C3, new ListPair(45, Atom.NIL))) + { + foreach (bool l7 in YP.get_code(C4)) + { + foreach (bool l8 in YP.unify(Chars, new ListPair(C2, new ListPair(45, More)))) + { + if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL))) + { + foreach (bool l11 in read_exponent(C4, More, NextCh)) + { + yield return false; + } + goto cutIf4; + } + } + foreach (bool l9 in YP.unify(More, Atom.NIL)) + { + foreach (bool l10 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL))) + { + } + } + foreach (bool l9 in YP.unify(More, new ListPair(48, Atom.NIL))) + { + foreach (bool l10 in YP.unify(NextCh, C4)) + { + yield return false; + } + } + cutIf4: + { } + } + } + goto cutIf3; + } + if (YP.equal(C3, new ListPair(43, Atom.NIL))) + { + foreach (bool l7 in YP.get_code(C4)) + { + foreach (bool l8 in YP.unify(Chars, new ListPair(C2, More))) + { + if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL))) + { + foreach (bool l11 in read_exponent(C4, More, NextCh)) + { + yield return false; + } + goto cutIf6; + } + } + foreach (bool l9 in YP.unify(More, Atom.NIL)) + { + foreach (bool l10 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL))) + { + } + } + foreach (bool l9 in YP.unify(More, new ListPair(48, Atom.NIL))) + { + foreach (bool l10 in YP.unify(NextCh, C4)) + { + yield return false; + } + } + cutIf6: + { } + } + } + goto cutIf5; + } + foreach (bool l6 in YP.unify(C4, C3)) + { + foreach (bool l7 in YP.unify(Chars, new ListPair(C2, More))) + { + if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL))) + { + foreach (bool l10 in read_exponent(C4, More, NextCh)) + { + yield return false; + } + goto cutIf7; + } + } + foreach (bool l8 in YP.unify(More, Atom.NIL)) + { + foreach (bool l9 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL))) + { + } + } + foreach (bool l8 in YP.unify(More, new ListPair(48, Atom.NIL))) + { + foreach (bool l9 in YP.unify(NextCh, C4)) + { + yield return false; + } + } + cutIf7: + { } + } + } + cutIf5: + cutIf3: + { } + } + goto cutIf2; + } + foreach (bool l4 in YP.unify(Chars, Atom.NIL)) + { + foreach (bool l5 in YP.unify(NextCh, C2)) + { + yield return false; + } + } + cutIf2: + cutIf1: + { } + } + } + } + } + + public static IEnumerable read_exponent(object C1, object arg2, object NextCh) + { + { + Variable Chars = new Variable(); + Variable C2 = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars))) + { + foreach (bool l3 in YP.get_code(C2)) + { + if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL))) + { + foreach (bool l6 in read_exponent(C2, Chars, NextCh)) + { + yield return false; + } + goto cutIf1; + } + } + foreach (bool l4 in YP.unify(Chars, Atom.NIL)) + { + foreach (bool l5 in YP.unify(NextCh, C2)) + { + yield return false; + } + } + cutIf1: + { } + } + } + } + } + + public static IEnumerable read_number(object C1, object Dict, object arg3) + { + { + Variable Number = new Variable(); + Variable Tokens = new Variable(); + Variable C2 = new Variable(); + Variable N = new Variable(); + Variable C = new Variable(); + Variable C3 = new Variable(); + Variable Digits = new Variable(); + foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor1(@"number", Number), Tokens))) + { + foreach (bool l3 in read_number4(C1, C2, 0, N)) + { + if (YP.equal(C2, 39)) + { + if (YP.greaterThanOrEqual(N, 2)) + { + if (YP.lessThanOrEqual(N, 36)) + { + foreach (bool l7 in read_based(N, 0, Number, C)) + { + foreach (bool l8 in read_tokens(C, Dict, Tokens)) + { + yield return false; + } + } + goto cutIf2; + } + } + if (YP.equal(N, 0)) + { + foreach (bool l6 in YP.get_code(C3)) + { + foreach (bool l7 in read_char(C3, -1, Number, C)) + { + foreach (bool l8 in read_tokens(C, Dict, Tokens)) + { + yield return false; + } + } + } + goto cutIf3; + } + foreach (bool l5 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** ~d' read as ~d '~n"), new ListPair(N, new ListPair(N, Atom.NIL)))) + { + foreach (bool l6 in YP.unify(Number, N)) + { + foreach (bool l7 in YP.unify(C, C2)) + { + foreach (bool l8 in read_tokens(C, Dict, Tokens)) + { + yield return false; + } + } + } + } + cutIf3: + cutIf2: + goto cutIf1; + } + if (YP.equal(C2, 46)) + { + foreach (bool l5 in YP.get_code(C3)) + { + if (YP.greaterThanOrEqual(C3, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C3, new ListPair(57, Atom.NIL))) + { + foreach (bool l8 in YP.number_codes(N, Digits)) + { + foreach (bool l9 in read_float(Number, Dict, Tokens, Digits, C3)) + { + yield return false; + } + } + goto cutIf5; + } + } + foreach (bool l6 in YP.unify(Number, N)) + { + foreach (bool l7 in read_fullstop(C3, Dict, Tokens)) + { + yield return false; + } + } + cutIf5: + { } + } + goto cutIf4; + } + foreach (bool l4 in YP.unify(Number, N)) + { + foreach (bool l5 in read_tokens(C2, Dict, Tokens)) + { + yield return false; + } + } + cutIf4: + cutIf1: + { } + } + } + } + } + + public static IEnumerable read_number4(object C0, object C, object N0, object N) + { + { + Variable N1 = new Variable(); + Variable C1 = new Variable(); + if (YP.greaterThanOrEqual(C0, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C0, new ListPair(57, Atom.NIL))) + { + foreach (bool l4 in YP.unify(N1, YP.add(YP.subtract(YP.multiply(N0, 10), new ListPair(48, Atom.NIL)), C0))) + { + foreach (bool l5 in YP.get_code(C1)) + { + foreach (bool l6 in read_number4(C1, C, N1, N)) + { + yield return false; + } + } + } + goto cutIf1; + } + } + if (YP.equal(C0, 95)) + { + foreach (bool l3 in YP.get_code(C1)) + { + foreach (bool l4 in read_number4(C1, C, N0, N)) + { + yield return false; + } + } + goto cutIf2; + } + foreach (bool l2 in YP.unify(C, C0)) + { + foreach (bool l3 in YP.unify(N, N0)) + { + yield return false; + } + } + cutIf2: + cutIf1: + { } + } + } + + public static IEnumerable read_based(object Base, object N0, object N, object C) + { + { + Variable C1 = new Variable(); + Variable Digit = new Variable(); + Variable N1 = new Variable(); + foreach (bool l2 in YP.get_code(C1)) + { + if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C1, new ListPair(57, Atom.NIL))) + { + foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, new ListPair(48, Atom.NIL)))) + { + if (YP.lessThan(Digit, Base)) + { + foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) + { + foreach (bool l8 in read_based(Base, N1, N, C)) + { + yield return false; + } + } + goto cutIf2; + } + if (YP.equal(C1, new ListPair(95, Atom.NIL))) + { + foreach (bool l7 in read_based(Base, N0, N, C)) + { + yield return false; + } + goto cutIf3; + } + foreach (bool l6 in YP.unify(N, N0)) + { + foreach (bool l7 in YP.unify(C, C1)) + { + yield return false; + } + } + cutIf3: + cutIf2: + { } + } + goto cutIf1; + } + } + if (YP.greaterThanOrEqual(C1, new ListPair(65, Atom.NIL))) + { + if (YP.lessThanOrEqual(C1, new ListPair(90, Atom.NIL))) + { + foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, YP.subtract(new ListPair(65, Atom.NIL), 10)))) + { + if (YP.lessThan(Digit, Base)) + { + foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) + { + foreach (bool l8 in read_based(Base, N1, N, C)) + { + yield return false; + } + } + goto cutIf5; + } + if (YP.equal(C1, new ListPair(95, Atom.NIL))) + { + foreach (bool l7 in read_based(Base, N0, N, C)) + { + yield return false; + } + goto cutIf6; + } + foreach (bool l6 in YP.unify(N, N0)) + { + foreach (bool l7 in YP.unify(C, C1)) + { + yield return false; + } + } + cutIf6: + cutIf5: + { } + } + goto cutIf4; + } + } + if (YP.greaterThanOrEqual(C1, new ListPair(97, Atom.NIL))) + { + if (YP.lessThanOrEqual(C1, new ListPair(122, Atom.NIL))) + { + foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, YP.subtract(new ListPair(97, Atom.NIL), 10)))) + { + if (YP.lessThan(Digit, Base)) + { + foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) + { + foreach (bool l8 in read_based(Base, N1, N, C)) + { + yield return false; + } + } + goto cutIf8; + } + if (YP.equal(C1, new ListPair(95, Atom.NIL))) + { + foreach (bool l7 in read_based(Base, N0, N, C)) + { + yield return false; + } + goto cutIf9; + } + foreach (bool l6 in YP.unify(N, N0)) + { + foreach (bool l7 in YP.unify(C, C1)) + { + yield return false; + } + } + cutIf9: + cutIf8: + { } + } + goto cutIf7; + } + } + foreach (bool l3 in YP.unify(Digit, 99)) + { + if (YP.lessThan(Digit, Base)) + { + foreach (bool l5 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) + { + foreach (bool l6 in read_based(Base, N1, N, C)) + { + yield return false; + } + } + goto cutIf10; + } + if (YP.equal(C1, new ListPair(95, Atom.NIL))) + { + foreach (bool l5 in read_based(Base, N0, N, C)) + { + yield return false; + } + goto cutIf11; + } + foreach (bool l4 in YP.unify(N, N0)) + { + foreach (bool l5 in YP.unify(C, C1)) + { + yield return false; + } + } + cutIf11: + cutIf10: + { } + } + cutIf7: + cutIf4: + cutIf1: + { } + } + } + } + + public static IEnumerable read_char(object Char, object Quote, object Result, object Next) + { + { + Variable C1 = new Variable(); + Variable C2 = new Variable(); + Variable C3 = new Variable(); + Variable Ch = new Variable(); + if (YP.equal(Char, 92)) + { + foreach (bool l3 in YP.get_code(C1)) + { + if (YP.lessThan(C1, 0)) + { + foreach (bool l5 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file in ~cquoted~c~n"), new ListPair(Quote, new ListPair(Quote, Atom.NIL)))) + { + foreach (bool l6 in YP.unify(Result, -1)) + { + foreach (bool l7 in YP.unify(Next, C1)) + { + yield return false; + } + } + } + goto cutIf2; + } + if (YP.lessThanOrEqual(C1, new ListPair(32, Atom.NIL))) + { + foreach (bool l5 in YP.get_code(C2)) + { + foreach (bool l6 in read_char(C2, Quote, Result, Next)) + { + yield return false; + } + } + goto cutIf3; + } + if (YP.equal(YP.bitwiseOr(C1, 32), new ListPair(99, Atom.NIL))) + { + foreach (bool l5 in YP.get_code(C2)) + { + foreach (bool l6 in read_char(C2, Quote, Result, Next)) + { + yield return false; + } + } + goto cutIf4; + } + if (YP.lessThanOrEqual(C1, new ListPair(55, Atom.NIL))) + { + if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL))) + { + foreach (bool l6 in YP.get_code(C2)) + { + if (YP.lessThanOrEqual(C2, new ListPair(55, Atom.NIL))) + { + if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) + { + foreach (bool l9 in YP.get_code(C3)) + { + if (YP.lessThanOrEqual(C3, new ListPair(55, Atom.NIL))) + { + if (YP.greaterThanOrEqual(C3, new ListPair(48, Atom.NIL))) + { + foreach (bool l12 in YP.get_code(Next)) + { + foreach (bool l13 in YP.unify(Result, YP.subtract(YP.add(YP.multiply(YP.add(YP.multiply(C1, 8), C2), 8), C3), YP.multiply(73, new ListPair(48, Atom.NIL))))) + { + yield return false; + } + } + goto cutIf7; + } + } + foreach (bool l10 in YP.unify(Next, C3)) + { + foreach (bool l11 in YP.unify(Result, YP.subtract(YP.add(YP.multiply(C1, 8), C2), YP.multiply(9, new ListPair(48, Atom.NIL))))) + { + yield return false; + } + } + cutIf7: + { } + } + goto cutIf6; + } + } + foreach (bool l7 in YP.unify(Next, C2)) + { + foreach (bool l8 in YP.unify(Result, YP.subtract(C1, new ListPair(48, Atom.NIL)))) + { + yield return false; + } + } + cutIf6: + { } + } + goto cutIf5; + } + } + if (YP.equal(C1, new ListPair(94, Atom.NIL))) + { + foreach (bool l5 in YP.get_code(C2)) + { + if (YP.lessThan(C2, 0)) + { + foreach (bool l7 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file in ~c..~c^..~c~n"), new ListPair(Quote, new ListPair(92, new ListPair(Quote, Atom.NIL))))) + { + foreach (bool l8 in YP.unify(Result, -1)) + { + foreach (bool l9 in YP.unify(Next, C2)) + { + yield return false; + } + } + } + goto cutIf9; + } + if (YP.equal(C2, new ListPair(63, Atom.NIL))) + { + foreach (bool l7 in YP.unify(Result, 127)) + { + foreach (bool l8 in YP.get_code(Next)) + { + yield return false; + } + } + goto cutIf10; + } + foreach (bool l6 in YP.unify(Result, YP.bitwiseAnd(C2, 31))) + { + foreach (bool l7 in YP.get_code(Next)) + { + yield return false; + } + } + cutIf10: + cutIf9: + { } + } + goto cutIf8; + } + foreach (bool l4 in escape_char(C1, Result)) + { + foreach (bool l5 in YP.get_code(Next)) + { + yield return false; + } + goto cutIf11; + } + foreach (bool l4 in YP.unify(Result, C1)) + { + foreach (bool l5 in YP.get_code(Next)) + { + yield return false; + } + } + cutIf11: + cutIf8: + cutIf5: + cutIf4: + cutIf3: + cutIf2: + { } + } + goto cutIf1; + } + if (YP.equal(Char, Quote)) + { + foreach (bool l3 in YP.get_code(Ch)) + { + if (YP.equal(Ch, Quote)) + { + foreach (bool l5 in YP.unify(Result, Quote)) + { + foreach (bool l6 in YP.get_code(Next)) + { + yield return false; + } + } + goto cutIf13; + } + foreach (bool l4 in YP.unify(Result, -1)) + { + foreach (bool l5 in YP.unify(Next, Ch)) + { + yield return false; + } + } + cutIf13: + { } + } + goto cutIf12; + } + if (YP.lessThan(Char, new ListPair(32, Atom.NIL))) + { + if (YP.notEqual(Char, 9)) + { + if (YP.notEqual(Char, 10)) + { + if (YP.notEqual(Char, 13)) + { + foreach (bool l6 in YP.unify(Result, -1)) + { + foreach (bool l7 in YP.unify(Next, Char)) + { + foreach (bool l8 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Strange character ~d ends ~ctoken~c~n"), new ListPair(Char, new ListPair(Quote, new ListPair(Quote, Atom.NIL))))) + { + yield return false; + } + } + } + goto cutIf14; + } + } + } + } + foreach (bool l2 in YP.unify(Result, Char)) + { + foreach (bool l3 in YP.get_code(Next)) + { + yield return false; + } + } + cutIf14: + cutIf12: + cutIf1: + { } + } + } + + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/PrologException.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/PrologException.cs new file mode 100644 index 0000000..f29c751 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/PrologException.cs @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + /// + /// A PrologException is used as the exception thrown by YP.throw(Term). + /// + public class PrologException : Exception + { + public readonly object _term; + + /// + /// Create a PrologException with the given Term. The printable exception message is the full Term. + /// + /// the term of the exception + /// + public PrologException(object Term) + : base(YP.getValue(Term).ToString()) + { + _term = YP.makeCopy(Term, new Variable.CopyStore()); + } + + /// + /// Create a PrologException where the Term is error(ErrorTerm, Message). + /// This uses YP.makeCopy to copy the ErrorTerm and Message so that they are valid after unbinding. + /// + /// the term of the exception + /// the message, converted to a string, to use as the printable exception message + /// + public PrologException(object ErrorTerm, object Message) + : base(YP.getValue(Message).ToString()) + { + _term = YP.makeCopy(new Functor2(Atom.a("error"), ErrorTerm, Message), new Variable.CopyStore()); + } + + public object Term + { + get { return _term; } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/UndefinedPredicateException.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/UndefinedPredicateException.cs new file mode 100644 index 0000000..4b6112f --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/UndefinedPredicateException.cs @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + /// + /// An UndefinedPredicateException extends PrologException to create an existence_error exception. + /// + public class UndefinedPredicateException : PrologException + { + private Atom _predicateName; + private int _arity; + + public UndefinedPredicateException(object message, Atom predicateName, int arity) + : base(new Functor2 + (Atom.a("existence_error"), Atom.a("procedure"), new Functor2(Atom.a("/"), predicateName, arity)), + message) + { + _predicateName = predicateName; + _arity = arity; + } + + public Atom PredicateName + { + get { return _predicateName; } + } + + public int Arity + { + get { return _arity; } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Variable.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Variable.cs new file mode 100644 index 0000000..2b5b0f1 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Variable.cs @@ -0,0 +1,196 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections; +using System.Collections.Generic; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + public interface IUnifiable + { + IEnumerable unify(object arg); + void addUniqueVariables(List variableSet); + object makeCopy(Variable.CopyStore copyStore); + bool termEqual(object term); + bool ground(); + } + + public class Variable : IUnifiable + { + // Use _isBound separate from _value so that it can be bound to any value, + // including null. + private bool _isBound = false; + private object _value; + + public object getValue() + { + if (!_isBound) + return this; + + object result = _value; + while (result is Variable) + { + if (!((Variable)result)._isBound) + return result; + + // Keep following the Variable chain. + result = ((Variable)result)._value; + } + + return result; + } + + public IEnumerable unify(object arg) + { + if (!_isBound) + { + _value = YP.getValue(arg); + if (_value == this) + // We are unifying this unbound variable with itself, so leave it unbound. + yield return false; + else + { + _isBound = true; + try + { + yield return false; + } + finally + { + // Remove the binding. + _isBound = false; + } + } + } + else + { + foreach (bool l1 in YP.unify(this, arg)) + yield return false; + } + } + + public override string ToString() + { + object value = getValue(); + if (value == this) + return "Variable"; + else + return getValue().ToString(); + } + + /// + /// If bound, call YP.addUniqueVariables on the value. Otherwise, if this unbound + /// variable is not already in variableSet, add it. + /// + /// + public void addUniqueVariables(List variableSet) + { + if (_isBound) + YP.addUniqueVariables(getValue(), variableSet); + else + { + if (variableSet.IndexOf(this) < 0) + variableSet.Add(this); + } + } + + /// + /// If bound, return YP.makeCopy for the value, else return copyStore.getCopy(this). + /// However, if copyStore is null, just return this. + /// + /// + /// + public object makeCopy(Variable.CopyStore copyStore) + { + if (_isBound) + return YP.makeCopy(getValue(), copyStore); + else + return copyStore == null ? this : copyStore.getCopy(this); + } + + public bool termEqual(object term) + { + if (_isBound) + return YP.termEqual(getValue(), term); + else + return this == YP.getValue(term); + } + + public bool ground() + { + if (_isBound) + // This is usually called by YP.ground which already did getValue, so this + // should never be reached, but check anyway. + return YP.ground(getValue()); + else + return false; + } + + /// + /// A CopyStore is used by makeCopy to track which Variable objects have + /// been copied. + /// + public class CopyStore + { + private List _inVariableSet = new List(); + private List _outVariableSet = new List(); + + /// + /// If inVariable has already been copied, return its copy. Otherwise, + /// return a fresh Variable associated with inVariable. + /// + /// + /// + public Variable getCopy(Variable inVariable) + { + int index = _inVariableSet.IndexOf(inVariable); + if (index >= 0) + return _outVariableSet[index]; + else + { + Variable outVariable = new Variable(); + _inVariableSet.Add(inVariable); + _outVariableSet.Add(outVariable); + return outVariable; + } + } + + /// + /// Return the number of unique variables that have been copied. + /// + /// + public int getNUniqueVariables() + { + return _inVariableSet.Count; + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YP.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YP.cs new file mode 100644 index 0000000..74704aa --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YP.cs @@ -0,0 +1,1644 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Reflection; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + /// + /// YP has static methods for general functions in Yield Prolog such as + /// and . + /// + public class YP + { + private static Fail _fail = new Fail(); + private static Repeat _repeat = new Repeat(); + private static Dictionary> _predicatesStore = + new Dictionary>(); + private static TextWriter _outputStream = System.Console.Out; + private static TextReader _inputStream = System.Console.In; + private static List _operatorTable = null; + + /// + /// An IClause is used so that dynamic predicates can call match. + /// + public interface IClause + { + IEnumerable match(object[] args); + } + + public static object getValue(object value) + { + if (value is Variable) + return ((Variable)value).getValue(); + else + return value; + } + + public static IEnumerable unify(object arg1, object arg2) + { + arg1 = getValue(arg1); + arg2 = getValue(arg2); + if (arg1 is IUnifiable) + return ((IUnifiable)arg1).unify(arg2); + else if (arg2 is IUnifiable) + return ((IUnifiable)arg2).unify(arg1); + else + { + // Arguments are "normal" types. + if (arg1.Equals(arg2)) + return new Succeed(); + else + return _fail; + } + } + + /// + /// This is used for the lookup key in _factStore. + /// + public struct NameArity + { + public readonly Atom _name; + public readonly int _arity; + + public NameArity(Atom name, int arity) + { + _name = name; + _arity = arity; + } + + public override bool Equals(object obj) + { + if (obj is NameArity) + { + NameArity nameArity = (NameArity)obj; + return nameArity._name.Equals(_name) && nameArity._arity.Equals(_arity); + } + else + { + return false; + } + } + + public override int GetHashCode() + { + return _name.GetHashCode() ^ _arity.GetHashCode(); + } + } + + /// + /// Convert term to an int. + /// If term is a single-element List, use its first element + /// (to handle the char types like "a"). If can't convert, throw an exception. + /// + /// + /// + public static int convertInt(object term) + { + term = YP.getValue(term); + if (term is Functor2 && ((Functor2)term)._name == Atom.DOT && + YP.getValue(((Functor2)term)._arg2) == Atom.NIL) + // Assume it is a char type like "a". + term = YP.getValue(((Functor2)term)._arg1); + + return (int)term; + } + + /// + /// Convert term to a double. This may convert an int to a double, etc. + /// If term is a single-element List, use its first element + /// (to handle the char types like "a"). If can't convert, throw an exception. + /// + /// + /// + public static double convertDouble(object term) + { + term = YP.getValue(term); + if (term is Functor2 && ((Functor2)term)._name == Atom.DOT && + YP.getValue(((Functor2)term)._arg2) == Atom.NIL) + // Assume it is a char type like "a". + term = YP.getValue(((Functor2)term)._arg1); + if (term is Variable) + throw new PrologException(Atom.a("instantiation_error"), + "Expected a number but the argument is an unbound variable"); + + return Convert.ToDouble(term); + } + + /// + /// If term is an integer, set intTerm. + /// If term is a single-element List, use its first element + /// (to handle the char types like "a"). Return true for success, false if can't convert. + /// We use a success return value because throwing an exception is inefficient. + /// + /// + /// + public static bool getInt(object term, out int intTerm) + { + term = YP.getValue(term); + if (term is Functor2 && ((Functor2)term)._name == Atom.DOT && + YP.getValue(((Functor2)term)._arg2) == Atom.NIL) + // Assume it is a char type like "a". + term = YP.getValue(((Functor2)term)._arg1); + + if (term is int) + { + intTerm = (int)term; + return true; + } + + intTerm = 0; + return false; + } + + public static bool equal(object x, object y) + { + x = YP.getValue(x); + if (x is DateTime) + return (DateTime)x == (DateTime)YP.getValue(y); + // Assume convertDouble converts an int to a double perfectly. + return YP.convertDouble(x) == YP.convertDouble(y); + } + + public static bool notEqual(object x, object y) + { + x = YP.getValue(x); + if (x is DateTime) + return (DateTime)x != (DateTime)YP.getValue(y); + // Assume convertDouble converts an int to a double perfectly. + return YP.convertDouble(x) != YP.convertDouble(y); + } + + public static bool greaterThan(object x, object y) + { + x = YP.getValue(x); + if (x is DateTime) + return (DateTime)x > (DateTime)YP.getValue(y); + // Assume convertDouble converts an int to a double perfectly. + return YP.convertDouble(x) > YP.convertDouble(y); + } + + public static bool lessThan(object x, object y) + { + x = YP.getValue(x); + if (x is DateTime) + return (DateTime)x < (DateTime)YP.getValue(y); + // Assume convertDouble converts an int to a double perfectly. + return YP.convertDouble(x) < YP.convertDouble(y); + } + + public static bool greaterThanOrEqual(object x, object y) + { + x = YP.getValue(x); + if (x is DateTime) + return (DateTime)x >= (DateTime)YP.getValue(y); + // Assume convertDouble converts an int to a double perfectly. + return YP.convertDouble(x) >= YP.convertDouble(y); + } + + public static bool lessThanOrEqual(object x, object y) + { + x = YP.getValue(x); + if (x is DateTime) + return (DateTime)x <= (DateTime)YP.getValue(y); + // Assume convertDouble converts an int to a double perfectly. + return YP.convertDouble(x) <= YP.convertDouble(y); + } + + public static object negate(object x) + { + int intX; + if (getInt(x, out intX)) + return -intX; + return -convertDouble(x); + } + + public static object abs(object x) + { + int intX; + if (getInt(x, out intX)) + return Math.Abs(intX); + return Math.Abs(convertDouble(x)); + } + + public static object sign(object x) + { + int intX; + if (getInt(x, out intX)) + return Math.Sign(intX); + return Math.Sign(convertDouble(x)); + } + + /// + /// The ISO standard returns an int. + /// + /// + /// + public static object floor(object x) + { + return (int)Math.Floor(convertDouble(x)); + } + + /// + /// The ISO standard returns an int. + /// + /// + /// + public static object truncate(object x) + { + return (int)Math.Truncate(convertDouble(x)); + } + + /// + /// The ISO standard returns an int. + /// + /// + /// + public static object round(object x) + { + return (int)Math.Round(convertDouble(x)); + } + + /// + /// The ISO standard returns an int. + /// + /// + /// + public static object ceiling(object x) + { + return (int)Math.Ceiling(convertDouble(x)); + } + + public static object sin(object x) + { + return Math.Sin(YP.convertDouble(x)); + } + + public static object cos(object x) + { + return Math.Cos(YP.convertDouble(x)); + } + + public static object atan(object x) + { + return Math.Atan(YP.convertDouble(x)); + } + + public static object exp(object x) + { + return Math.Exp(YP.convertDouble(x)); + } + + public static object log(object x) + { + return Math.Log(YP.convertDouble(x)); + } + + public static object sqrt(object x) + { + return Math.Sqrt(convertDouble(x)); + } + + public static object bitwiseComplement(object x) + { + return ~YP.convertInt(x); + } + + public static object add(object x, object y) + { + int intX, intY; + if (getInt(x, out intX) && getInt(y, out intY)) + return intX + intY; + return convertDouble(x) + convertDouble(y); + } + + public static object subtract(object x, object y) + { + int intX, intY; + if (getInt(x, out intX) && getInt(y, out intY)) + return intX - intY; + return convertDouble(x) - convertDouble(y); + } + + public static object multiply(object x, object y) + { + int intX, intY; + if (getInt(x, out intX) && getInt(y, out intY)) + return intX * intY; + return convertDouble(x) * convertDouble(y); + } + + /// + /// Return floating point, even if both arguments are integer. + /// + /// + /// + /// + public static object divide(object x, object y) + { + return convertDouble(x) / convertDouble(y); + } + + public static object intDivide(object x, object y) + { + int intX, intY; + if (getInt(x, out intX) && getInt(y, out intY)) + return intX / intY; + // Still allow passing a double, but treat as an int. + return (int)convertDouble(x) / (int)convertDouble(y); + } + + public static object mod(object x, object y) + { + int intX, intY; + if (getInt(x, out intX) && getInt(y, out intY)) + return intX % intY; + // Still allow passing a double, but treat as an int. + return (int)convertDouble(x) % (int)convertDouble(y); + } + + public static object pow(object x, object y) + { + return Math.Pow(YP.convertDouble(x), YP.convertDouble(y)); + } + + public static object bitwiseShiftRight(object x, object y) + { + return YP.convertInt(x) >> YP.convertInt(y); + } + + public static object bitwiseShiftLeft(object x, object y) + { + return YP.convertInt(x) << YP.convertInt(y); + } + + public static object bitwiseAnd(object x, object y) + { + return YP.convertInt(x) & YP.convertInt(y); + } + + public static object bitwiseOr(object x, object y) + { + return YP.convertInt(x) | YP.convertInt(y); + } + + public static object min(object x, object y) + { + int intX, intY; + if (getInt(x, out intX) && getInt(y, out intY)) + return Math.Min(intX, intY); + return Math.Min(convertDouble(x), convertDouble(y)); + } + + public static object max(object x, object y) + { + int intX, intY; + if (getInt(x, out intX) && getInt(y, out intY)) + return Math.Max(intX, intY); + return Math.Max(convertDouble(x), convertDouble(y)); + } + + public static IEnumerable copy_term(object inTerm, object outTerm) + { + return YP.unify(outTerm, YP.makeCopy(inTerm, new Variable.CopyStore())); + } + + public static void addUniqueVariables(object term, List variableSet) + { + term = YP.getValue(term); + if (term is IUnifiable) + ((IUnifiable)term).addUniqueVariables(variableSet); + } + + public static object makeCopy(object term, Variable.CopyStore copyStore) + { + term = YP.getValue(term); + if (term is IUnifiable) + return ((IUnifiable)term).makeCopy(copyStore); + else + // term is a "normal" type. Assume it is ground. + return term; + } + + /// + /// Sort the array in place according to termLessThan. This does not remove duplicates + /// + /// + public static void sortArray(object[] array) + { + Array.Sort(array, YP.compareTerms); + } + + /// + /// Sort the array in place according to termLessThan. This does not remove duplicates + /// + /// + public static void sortArray(List array) + { + array.Sort(YP.compareTerms); + } + + /// + /// Sort List according to termLessThan, remove duplicates and unify with Sorted. + /// + /// + /// + /// + public static IEnumerable sort(object List, object Sorted) + { + object[] array = ListPair.toArray(List); + if (array == null) + return YP.fail(); + if (array.Length > 1) + sortArray(array); + return YP.unify(Sorted, ListPair.makeWithoutRepeatedTerms(array)); + } + + + + /// + /// Use YP.unify to unify each of the elements of the two arrays, and yield + /// once if they all unify. + /// + /// + /// + /// + public static IEnumerable unifyArrays(object[] array1, object[] array2) + { + if (array1.Length != array2.Length) + yield break; + + IEnumerator[] iterators = new IEnumerator[array1.Length]; + bool gotMatch = true; + int nIterators = 0; + // Try to bind all the arguments. + for (int i = 0; i < array1.Length; ++i) + { + IEnumerator iterator = YP.unify(array1[i], array2[i]).GetEnumerator(); + iterators[nIterators++] = iterator; + // MoveNext() is true if YP.unify succeeds. + if (!iterator.MoveNext()) + { + gotMatch = false; + break; + } + } + + try + { + if (gotMatch) + yield return false; + } + finally + { + // Manually finalize all the iterators. + for (int i = 0; i < nIterators; ++i) + iterators[i].Dispose(); + } + } + + /// + /// Return an iterator (which you can use in a for-in loop) which does + /// zero iterations. This returns a pre-existing iterator which is + /// more efficient than letting the compiler generate a new one. + /// + /// + public static IEnumerable fail() + { + return _fail; + } + + /// + /// Return an iterator (which you can use in a for-in loop) which does + /// one iteration. This returns a pre-existing iterator which is + /// more efficient than letting the compiler generate a new one. + /// + /// + public static IEnumerable succeed() + { + return new Succeed(); + } + + /// + /// Return an iterator (which you can use in a for-in loop) which repeats + /// indefinitely. This returns a pre-existing iterator which is + /// more efficient than letting the compiler generate a new one. + /// + /// + public static IEnumerable repeat() + { + return _repeat; + } + + public static IEnumerable univ(object Term, object List) + { + Term = YP.getValue(Term); + List = YP.getValue(List); + + if (nonvar(Term)) + return YP.unify(new ListPair + (getFunctorName(Term), ListPair.make(getFunctorArgs(Term))), List); + + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l1 in new ListPair(Name, ArgList).unify(List)) + { + object[] args = ListPair.toArray(ArgList); + if (args == null) + throw new Exception("Expected a list. Got: " + ArgList.getValue()); + if (args.Length == 0) + // Return the Name, even if it is not an Atom. + return YP.unify(Term, Name); + if (!atom(Name)) + throw new Exception("Expected an atom. Got: " + Name.getValue()); + + return YP.unify(Term, Functor.make((Atom)YP.getValue(Name), args)); + } + + return YP.fail(); + } + + public static IEnumerable functor(object Term, object FunctorName, object Arity) + { + Term = YP.getValue(Term); + FunctorName = YP.getValue(FunctorName); + Arity = YP.getValue(Arity); + + if (!(Term is Variable)) + { + foreach (bool l1 in YP.unify(FunctorName, getFunctorName(Term))) + { + foreach (bool l2 in YP.unify(Arity, getFunctorArgs(Term).Length)) + yield return false; + } + } + else + throw new NotImplementedException("Debug: must finish functor/3"); + } + + public static IEnumerable arg(object ArgNumber, object Term, object Value) + { + if (YP.var(ArgNumber)) + throw new NotImplementedException("Debug: must finish arg/3"); + else + { + int argNumberInt = convertInt(ArgNumber); + if (argNumberInt < 0) + throw new Exception("ArgNumber must be non-negative"); + object[] termArgs = YP.getFunctorArgs(Term); + // Silently fail if argNumberInt is out of range. + if (argNumberInt >= 1 && argNumberInt <= termArgs.Length) + { + // The first ArgNumber is at 1, not 0. + foreach (bool l1 in YP.unify(Value, termArgs[argNumberInt - 1])) + yield return false; + } + } + } + + public static bool termEqual(object Term1, object Term2) + { + Term1 = YP.getValue(Term1); + if (Term1 is IUnifiable) + return ((IUnifiable)Term1).termEqual(Term2); + return Term1.Equals(YP.getValue(Term2)); + } + + public static bool termNotEqual(object Term1, object Term2) + { + return !termEqual(Term1, Term2); + } + + public static bool termLessThan(object Term1, object Term2) + { + Term1 = YP.getValue(Term1); + Term2 = YP.getValue(Term2); + int term1TypeCode = getTypeCode(Term1); + int term2TypeCode = getTypeCode(Term2); + if (term1TypeCode != term2TypeCode) + return term1TypeCode < term2TypeCode; + + // The terms are the same type code. + if (term1TypeCode == -2) + { + // Variable. + // We always check for equality first because we want to be sure + // that less than returns false if the terms are equal, in + // case that the less than check really behaves like less than or equal. + if ((Variable)Term1 != (Variable)Term2) + // The hash code should be unique to a Variable object. + return Term1.GetHashCode() < Term2.GetHashCode(); + return false; + } + if (term1TypeCode == 0) + return ((Atom)Term1)._name.CompareTo(((Atom)Term2)._name) < 0; + if (term1TypeCode == 1) + return ((Functor1)Term1).lessThan((Functor1)Term2); + if (term1TypeCode == 2) + return ((Functor2)Term1).lessThan((Functor2)Term2); + if (term1TypeCode == 3) + return ((Functor3)Term1).lessThan((Functor3)Term2); + if (term1TypeCode == 4) + return ((Functor)Term1).lessThan((Functor)Term2); + + // Type code is -1 for general objects. First compare their type names. + // Note that this puts Double before Int32 as required by ISO Prolog. + string term1TypeName = Term1.GetType().ToString(); + string term2TypeName = Term2.GetType().ToString(); + if (term1TypeName != term2TypeName) + return term1TypeName.CompareTo(term2TypeName) < 0; + + // The terms are the same type name. + if (Term1 is int) + return (int)Term1 < (int)Term2; + else if (Term1 is double) + return (double)Term1 < (double)Term2; + else if (Term1 is DateTime) + return (DateTime)Term1 < (DateTime)Term2; + else if (Term1 is String) + return ((String)Term1).CompareTo((String)Term2) < 0; + // Debug: Should we try arrays, etc.? + + if (!Term1.Equals(Term2)) + // Could be equal or greater than. + return Term1.GetHashCode() < Term2.GetHashCode(); + return false; + } + + /// + /// Type code is -2 if term is a Variable, 0 if it is an Atom, + /// 1 if it is a Functor1, 2 if it is a Functor2, 3 if it is a Functor3, + /// 4 if it is Functor. + /// Otherwise, type code is -1. + /// This does not call YP.getValue(term). + /// + /// + /// + private static int getTypeCode(object term) + { + if (term is Variable) + return -2; + else if (term is Atom) + return 0; + else if (term is Functor1) + return 1; + else if (term is Functor2) + return 2; + else if (term is Functor3) + return 3; + else if (term is Functor) + return 4; + else + return -1; + } + + public static bool termLessThanOrEqual(object Term1, object Term2) + { + if (YP.termEqual(Term1, Term2)) + return true; + return YP.termLessThan(Term1, Term2); + } + + public static bool termGreaterThan(object Term1, object Term2) + { + return !YP.termLessThanOrEqual(Term1, Term2); + } + + public static bool termGreaterThanOrEqual(object Term1, object Term2) + { + // termLessThan should ensure that it returns false if terms are equal, + // so that this would return true. + return !YP.termLessThan(Term1, Term2); + } + + public static int compareTerms(object Term1, object Term2) + { + if (YP.termEqual(Term1, Term2)) + return 0; + else if (YP.termLessThan(Term1, Term2)) + return -1; + else + return 1; + } + + public static bool ground(object Term) + { + Term = YP.getValue(Term); + if (Term is IUnifiable) + return ((IUnifiable)Term).ground(); + return true; + } + + public static IEnumerable current_op + (object Priority, object Specifier, object Operator) + { + if (_operatorTable == null) + { + // Initialize. + _operatorTable = new List(); + _operatorTable.Add(new object[] { 1200, Atom.a("xfx"), Atom.a(":-") }); + _operatorTable.Add(new object[] { 1200, Atom.a("xfx"), Atom.a("-->") }); + _operatorTable.Add(new object[] { 1200, Atom.a("fx"), Atom.a(":-") }); + _operatorTable.Add(new object[] { 1200, Atom.a("fx"), Atom.a("?-") }); + _operatorTable.Add(new object[] { 1100, Atom.a("xfy"), Atom.a(";") }); + _operatorTable.Add(new object[] { 1050, Atom.a("xfy"), Atom.a("->") }); + _operatorTable.Add(new object[] { 1000, Atom.a("xfy"), Atom.a(",") }); + _operatorTable.Add(new object[] { 900, Atom.a("fy"), Atom.a("\\+") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("\\=") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("==") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("\\==") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@<") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@=<") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@>") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@>=") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=..") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("is") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=:=") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=\\=") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("<") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=<") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a(">") }); + _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a(">=") }); + _operatorTable.Add(new object[] { 600, Atom.a("xfy"), Atom.a(":") }); + _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("+") }); + _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("-") }); + _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("/\\") }); + _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("\\/") }); + _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("*") }); + _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("/") }); + _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("//") }); + _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("rem") }); + _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("mod") }); + _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("<<") }); + _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a(">>") }); + _operatorTable.Add(new object[] { 200, Atom.a("xfx"), Atom.a("**") }); + _operatorTable.Add(new object[] { 200, Atom.a("xfy"), Atom.a("^") }); + _operatorTable.Add(new object[] { 200, Atom.a("fy"), Atom.a("-") }); + _operatorTable.Add(new object[] { 200, Atom.a("fy"), Atom.a("\\") }); + // Debug: This is hacked in to run the Prolog test suite until we implement op/3. + _operatorTable.Add(new object[] { 20, Atom.a("xfx"), Atom.a("<--") }); + } + + object[] args = new object[] { Priority, Specifier, Operator }; + foreach (object[] answer in _operatorTable) + { + foreach (bool l1 in YP.unifyArrays(args, answer)) + yield return false; + } + } + + public static IEnumerable atom_length(object atom, object Length) + { + return YP.unify(Length, ((Atom)YP.getValue(atom))._name.Length); + } + + public static IEnumerable atom_concat(object Start, object End, object Whole) + { + // Debug: Should implement for var(Start) which is a kind of search. + // Debug: Should we try to preserve the _declaringClass? + return YP.unify(Whole, Atom.a(((Atom)YP.getValue(Start))._name + + ((Atom)YP.getValue(End))._name)); + } + + public static IEnumerable sub_atom + (object atom, object Before, object Length, object After, object Sub_atom) + { + // Debug: Should implement for var(atom) which is a kind of search. + // Debug: Should we try to preserve the _declaringClass? + Atom atomAtom = (Atom)YP.getValue(atom); + int beforeInt = YP.convertInt(Before); + int lengthInt = YP.convertInt(Length); + if (beforeInt < 0) + throw new Exception("Before must be non-negative"); + if (lengthInt < 0) + throw new Exception("Length must be non-negative"); + int afterInt = atomAtom._name.Length - (beforeInt + lengthInt); + if (afterInt >= 0) + { + foreach (bool l1 in YP.unify(After, afterInt)) + { + foreach (bool l2 in YP.unify + (Sub_atom, Atom.a(atomAtom._name.Substring(beforeInt, lengthInt)))) + yield return false; + } + } + } + + public static IEnumerable atom_codes(object atom, object List) + { + atom = YP.getValue(atom); + List = YP.getValue(List); + + if (nonvar(atom)) + { + string name = ((Atom)atom)._name; + object codeList = Atom.NIL; + // Start from the back to make the list. + for (int i = name.Length - 1; i >= 0; --i) + codeList = new ListPair((int)name[i], codeList); + return YP.unify(List, codeList); + } + { + object[] codeArray = ListPair.toArray(List); + char[] charArray = new char[codeArray.Length]; + for (int i = 0; i < codeArray.Length; ++i) + charArray[i] = (char)YP.convertInt(codeArray[i]); + return YP.unify(atom, Atom.a(new String(charArray))); + } + } + + public static IEnumerable number_codes(object number, object List) + { + number = YP.getValue(number); + List = YP.getValue(List); + + if (nonvar(number)) + { + string numberString = null; + // Try converting to an int first. + int intNumber; + if (YP.getInt(number, out intNumber)) + numberString = intNumber.ToString(); + else + numberString = YP.doubleToString(YP.convertDouble(number)); + + object codeList = Atom.NIL; + // Start from the back to make the list. + for (int i = numberString.Length - 1; i >= 0; --i) + codeList = new ListPair((int)numberString[i], codeList); + return YP.unify(List, codeList); + } + { + object[] codeArray = ListPair.toArray(List); + char[] charArray = new char[codeArray.Length]; + for (int i = 0; i < codeArray.Length; ++i) + charArray[i] = (char)YP.convertInt(codeArray[i]); + String numberString = new String(charArray); + // Debug: Is there a way in C# to ask if a string parses as int without throwing an exception? + try + { + // Try an int first. + return YP.unify(number, Convert.ToInt32(numberString)); + } + catch (FormatException) { } + return YP.unify(number, Convert.ToDouble(numberString)); + } + } + + /// + /// If term is an Atom or functor type, return its name. + /// Otherwise, return term. + /// + /// + /// + public static object getFunctorName(object term) + { + term = YP.getValue(term); + if (term is Functor1) + return ((Functor1)term)._name; + else if (term is Functor2) + return ((Functor2)term)._name; + else if (term is Functor3) + return ((Functor3)term)._name; + else if (term is Functor) + return ((Functor)term)._name; + else + return term; + } + + /// + /// If term is an Atom or functor type, return an array of its args. + /// Otherwise, return an empty array. + /// + /// + /// + public static object[] getFunctorArgs(object term) + { + term = YP.getValue(term); + if (term is Functor1) + { + Functor1 functor = (Functor1)term; + return new object[] { functor._arg1 }; + } + else if (term is Functor2) + { + Functor2 functor = (Functor2)term; + return new object[] { functor._arg1, functor._arg2 }; + } + else if (term is Functor3) + { + Functor3 functor = (Functor3)term; + return new object[] { functor._arg1, functor._arg2, functor._arg3 }; + } + else if (term is Functor) { + Functor functor = (Functor)term; + return functor._args; + } + else + return new object[0]; + } + + public static bool var(object Term) + { + return YP.getValue(Term) is Variable; + } + + public static bool nonvar(object Term) + { + return !YP.var(Term); + } + + public static bool atom(object Term) + { + return YP.getValue(Term) is Atom; + } + + public static bool integer(object Term) + { + // Debug: Should exhaustively check for all integer types. + return getValue(Term) is int; + } + + // Use isFloat instead of float because it is a reserved keyword. + public static bool isFloat(object Term) + { + // Debug: Should exhaustively check for all float types. + return getValue(Term) is double; + } + + public static bool number(object Term) + { + return YP.integer(Term) || YP.isFloat(Term); + } + + public static bool atomic(object Term) + { + return YP.atom(Term) || YP.number(Term); + } + + public static bool compound(object Term) + { + Term = getValue(Term); + return Term is Functor1 || Term is Functor2 || Term is Functor3 || Term is Functor; + } + + public static void see(object input) + { + input = YP.getValue(input); + if (input is TextReader) + { + _inputStream = (TextReader)input; + return; + } + else if (input is Atom) + { + _inputStream = new StreamReader(((Atom)input)._name); + return; + } + else if (input is String) + { + _inputStream = new StreamReader((String)input); + return; + } + else + throw new InvalidOperationException("Can't open stream for " + input); + } + + public static void seen() + { + if (_inputStream == Console.In) + return; + _inputStream.Close(); + _inputStream = Console.In; + } + + public static void tell(object output) + { + output = YP.getValue(output); + if (output is TextWriter) + { + _outputStream = (TextWriter)output; + return; + } + else if (output is Atom) + { + _outputStream = new StreamWriter(((Atom)output)._name); + return; + } + else if (output is String) + { + _outputStream = new StreamWriter((String)output); + return; + } + else + throw new InvalidOperationException("Can't open stream for " + output); + } + + public static void told() + { + if (_outputStream == Console.Out) + return; + _outputStream.Close(); + _outputStream = Console.Out; + } + + public static IEnumerable current_output(object Stream) + { + return YP.unify(Stream, _outputStream); + } + + public static void write(object x) + { + x = YP.getValue(x); + if (x is double) + _outputStream.Write(doubleToString((double)x)); + else + _outputStream.Write(x.ToString()); + } + + /// + /// Format x as a string, making sure that it will parse as an int later. I.e., for 1.0, don't just + /// use "1" which will parse as an int. + /// + /// + /// + private static string doubleToString(double x) + { + string xString = x.ToString(); + // Debug: Is there a way in C# to ask if a string parses as int without throwing an exception? + try + { + Convert.ToInt32(xString); + // The string will parse as an int, not a double, so re-format so that it does. + // Use float if possible, else exponential if it would be too big. + return x.ToString(x >= 100000.0 ? "E1" : "f1"); + } + catch (FormatException) + { + // Assume it will parse as a double. + } + return xString; + } + + public static void put_code(object x) + { + _outputStream.Write((char)YP.convertInt(x)); + } + + public static void nl() + { + _outputStream.WriteLine(); + } + + public static IEnumerable get_code(object code) + { + return YP.unify(code, _inputStream.Read()); + } + + public static void asserta(object Term, Type declaringClass) + { + assertDynamic(Term, declaringClass, true); + } + + public static void assertz(object Term, Type declaringClass) + { + assertDynamic(Term, declaringClass, false); + } + + public static void assertDynamic(object Term, Type declaringClass, bool prepend) + { + Term = getValue(Term); + if (Term is Variable) + throw new PrologException("instantiation_error", "Term to assert is an unbound variable"); + + Variable.CopyStore copyStore = new Variable.CopyStore(); + object TermCopy = makeCopy(Term, copyStore); + object Head, Body; + if (TermCopy is Functor2 && ((Functor2)TermCopy)._name == Atom.RULE) + { + Head = YP.getValue(((Functor2)TermCopy)._arg1); + Body = YP.getValue(((Functor2)TermCopy)._arg2); + } + else + { + Head = TermCopy; + Body = Atom.a("true"); + } + + Atom name = getFunctorName(Head) as Atom; + if (name == null) + // name is a non-Atom, such as a number. + throw new PrologException + (new Functor2("type_error", Atom.a("callable"), Head), "Term to assert is not callable"); + object[] args = getFunctorArgs(Head); + if (!isDynamic(name, args.Length)) + throw new PrologException + (new Functor3("permission_error", Atom.a("modify"), Atom.a("static_procedure"), + new Functor2(Atom.SLASH, name, args.Length)), + "Assert cannot modify static predicate " + name + "/" + args.Length); + + if (copyStore.getNUniqueVariables() == 0 && Body == Atom.a("true")) + { + // Debug: Until IndexedAnswers supports prepend, compile the fact so we can prepend it below. + if (!prepend) + { + // This is a fact with no unbound variables + // assertFact uses IndexedAnswers, so don't we don't need to compile. + assertFact(name, args); + return; + } + } + + IClause clause = YPCompiler.compileAnonymousClause(Head, Body, declaringClass); + + // Add the clause to the entry in _predicatesStore. + NameArity nameArity = new NameArity(name, args.Length); + List clauses; + if (!_predicatesStore.TryGetValue(nameArity, out clauses)) + // Create an entry for the nameArity. + _predicatesStore[nameArity] = (clauses = new List()); + + if (prepend) + clauses.Insert(0, clause); + else + clauses.Add(clause); + } + + private static bool isDynamic(Atom name, int arity) + { + if (arity == 2 && (name == Atom.a(",") || name == Atom.a(";") || name == Atom.DOT)) + return false; + // Use the same mapping to static predicates in YP as the compiler. + foreach (bool l1 in YPCompiler.functorCallYPFunctionName(name, arity, new Variable())) + return false; + // Debug: Do we need to check if name._module is null? + return true; + } + + /// + /// Assert values at the end of the set of facts for the predicate with the + /// name and with arity values.Length. + /// + /// must be an Atom + /// the array of arguments to the fact predicate. + /// It is an error if an value has an unbound variable. + public static void assertFact(Atom name, object[] values) + { + NameArity nameArity = new NameArity(name, values.Length); + List clauses; + IndexedAnswers indexedAnswers; + if (!_predicatesStore.TryGetValue(nameArity, out clauses)) + { + // Create an IndexedAnswers as the first clause of the predicate. + _predicatesStore[nameArity] = (clauses = new List()); + clauses.Add(indexedAnswers = new IndexedAnswers()); + } + else + { + indexedAnswers = clauses[clauses.Count - 1] as IndexedAnswers; + if (indexedAnswers == null) + // The latest clause is not an IndexedAnswers, so add one. + clauses.Add(indexedAnswers = new IndexedAnswers()); + } + + indexedAnswers.addAnswer(values); + } + + /// + /// Match all clauses of the dynamic predicate with the name and with arity + /// arguments.Length. + /// It is an error if the predicate is not defined. + /// + /// must be an Atom + /// an array of arity number of arguments + /// an iterator which you can use in foreach + public static IEnumerable matchDynamic(Atom name, object[] arguments) + { + List clauses; + if (!_predicatesStore.TryGetValue(new NameArity(name, arguments.Length), out clauses)) + throw new UndefinedPredicateException + ("Undefined fact: " + name + "/" + arguments.Length, name, + arguments.Length); + + if (clauses.Count == 1) + // Usually there is only one clause, so return it without needing to wrap it in an iterator. + return clauses[0].match(arguments); + else + return matchAllClauses(clauses, arguments); + } + + /// + /// Call match(arguments) for each IClause in clauses. We make this a separate + /// function so that matchDynamic itself does not need to be an iterator object. + /// + /// + /// + /// + private static IEnumerable matchAllClauses(List clauses, object[] arguments) + { + // Debug: If the clause asserts another clause into this same predicate, the iterator + // over clauses will be corrupted. Should we take the time to copy clauses? + foreach (IClause clause in clauses) + { + foreach (bool lastCall in clause.match(arguments)) + { + yield return false; + if (lastCall) + // This happens after a cut in a clause. + yield break; + } + } + } + + /// + /// This is deprecated and just calls matchDynamic. This matches all clauses, + /// not just the ones defined with assertFact. + /// + /// + /// + /// + public static IEnumerable matchFact(Atom name, object[] arguments) + { + return matchDynamic(name, arguments); + } + + /// + /// This actually searches all clauses, not just + /// the ones defined with assertFact, but we keep the name for + /// backwards compatibility. + /// + /// must be an Atom + /// an array of arity number of arguments + public static void retractFact(Atom name, object[] arguments) + { + NameArity nameArity = new NameArity(name, arguments.Length); + List clauses; + if (!_predicatesStore.TryGetValue(nameArity, out clauses)) + // Can't find, so ignore. + return; + + foreach (object arg in arguments) + { + if (!YP.var(arg)) + throw new InvalidOperationException("All arguments must be unbound"); + } + // Set to a fresh empty IndexedAnswers. + _predicatesStore[nameArity] = (clauses = new List()); + clauses.Add(new IndexedAnswers()); + } + + public static IEnumerable current_predicate(object NameSlashArity) + { + NameSlashArity = YP.getValue(NameSlashArity); + // First check if Name and Arity are nonvar so we can do a direct lookup. + if (YP.ground(NameSlashArity)) + { + if (NameSlashArity is Functor2) + { + Functor2 NameArityFunctor = (Functor2)NameSlashArity; + if (NameArityFunctor._name == Atom.SLASH) + { + if (_predicatesStore.ContainsKey(new NameArity + ((Atom)YP.getValue(NameArityFunctor._arg1), + (int)YP.getValue(NameArityFunctor._arg2)))) + // The predicate is defined. + yield return false; + } + } + yield break; + } + + foreach (NameArity key in _predicatesStore.Keys) + { + foreach (bool l1 in YP.unify + (new Functor2(Atom.SLASH, key._name, key._arity), NameSlashArity)) + yield return false; + } + } + + /// + /// Use YP.getFunctorName(Goal) and invoke the static method of this name in the + /// declaringClass, using arguments from YP.getFunctorArgs(Goal). + /// Note that Goal must be a simple functor, not a complex expression. + /// If not found, this throws UndefinedPredicateException. + /// + /// + /// the class for looking up default function references + /// + public static IEnumerable getIterator(object Goal, Type declaringClass) + { + Goal = YP.getValue(Goal); + if (Goal is Variable) + throw new PrologException("instantiation_error", "Goal to call is an unbound variable"); +#if true + List variableSetList = new List(); + addUniqueVariables(Goal, variableSetList); + Variable[] variableSet = variableSetList.ToArray(); + + // Use Atom.F since it is ignored. + return YPCompiler.compileAnonymousClause + (Functor.make(Atom.F, variableSet), Goal, declaringClass).match(variableSet); +#else + Atom name; + object[] args; + while (true) + { + name = (Atom)YP.getFunctorName(Goal); + args = YP.getFunctorArgs(Goal); + if (name == Atom.HAT && args.Length == 2) + // Assume this is called from a bagof operation. Skip the leading qualifiers. + Goal = YP.getValue(((Functor2)Goal)._arg2); + else + break; + } + try + { + return (IEnumerable)declaringClass.InvokeMember + (name._name, BindingFlags.InvokeMethod, null, null, args); + } + catch (TargetInvocationException exception) + { + throw exception.InnerException; + } + catch (MissingMethodException) + { + throw new UndefinedPredicateException + ("Cannot find predicate function: " + name + "/" + args.Length + " in " + + declaringClass.FullName, name, args.Length); + } +#endif + } + + public static void throwException(object Term) + { + throw new PrologException(Term); + } + + /// + /// script_event calls hosting script with events as a callback method. + /// + /// + /// + /// + public static void script_event(object script_event, object script_params) + { + string function = ((Atom)YP.getValue(script_event))._name; + object[] array = ListPair.toArray(script_params); + if (array == null) + return; // YP.fail(); + if (array.Length > 1) + { + //m_CmdManager.m_ScriptEngine.m_EventQueManager.AddToScriptQueue + //(localID, itemID, function, array); + // sortArray(array); + } + //return YP.unify(Sorted, ListPair.makeWithoutRepeatedTerms(array)); + } + + /// + /// An enumerator that does zero loops. + /// + private class Fail : IEnumerator, IEnumerable + { + public bool MoveNext() + { + return false; + } + + public IEnumerator GetEnumerator() + { + return (IEnumerator)this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public bool Current + { + get { return true; } + } + + object IEnumerator.Current + { + get { return true; } + } + + public void Dispose() + { + } + + public void Reset() + { + throw new NotImplementedException(); + } + } + + /// + /// An enumerator that does one iteration. + /// + private class Succeed : IEnumerator, IEnumerable + { + private bool _didIteration = false; + + public bool MoveNext() + { + if (!_didIteration) + { + _didIteration = true; + return true; + } + else + return false; + } + + public IEnumerator GetEnumerator() + { + return (IEnumerator)this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public bool Current + { + get { return false; } + } + + object IEnumerator.Current + { + get { return false; } + } + + public void Dispose() + { + } + + public void Reset() + { + throw new NotImplementedException(); + } + } + + /// + /// An enumerator that repeats forever. + /// + private class Repeat : IEnumerator, IEnumerable + { + public bool MoveNext() + { + return true; + } + + public IEnumerator GetEnumerator() + { + return (IEnumerator)this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public bool Current + { + get { return false; } + } + + object IEnumerator.Current + { + get { return false; } + } + + public void Dispose() + { + } + + public void Reset() + { + throw new NotImplementedException(); + } + } + + /// + /// An enumerator that wraps another enumerator in order to catch a PrologException. + /// + public class Catch : IEnumerator, IEnumerable + { + private IEnumerator _enumerator; + private PrologException _exception = null; + + public Catch(IEnumerable iterator) + { + _enumerator = iterator.GetEnumerator(); + } + + /// + /// Call _enumerator.MoveNext(). If it throws a PrologException, set _exception + /// and return false. After this returns false, call unifyExceptionOrThrow. + /// Assume that, after this returns false, it will not be called again. + /// + /// + public bool MoveNext() + { + try + { + return _enumerator.MoveNext(); + } + catch (PrologException exception) + { + _exception = exception; + return false; + } + } + + /// + /// Call this after MoveNext() returns false to check for an exception. If + /// MoveNext did not get a PrologException, don't yield. + /// Otherwise, unify the exception with Catcher and yield so the caller can + /// do the handler code. However, if can't unify with Catcher then throw the exception. + /// + /// + /// + public IEnumerable unifyExceptionOrThrow(object Catcher) + { + if (_exception != null) + { + bool didUnify = false; + foreach (bool l1 in YP.unify(_exception._term, Catcher)) + { + didUnify = true; + yield return false; + } + if (!didUnify) + throw _exception; + } + } + + public IEnumerator GetEnumerator() + { + return (IEnumerator)this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public bool Current + { + get { return _enumerator.Current; } + } + + object IEnumerator.Current + { + get { return _enumerator.Current; } + } + + public void Dispose() + { + _enumerator.Dispose(); + } + + public void Reset() + { + throw new NotImplementedException(); + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YPCompiler.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YPCompiler.cs new file mode 100644 index 0000000..f2f8145 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YPCompiler.cs @@ -0,0 +1,5651 @@ +/* + * Copyright (C) 2007-2008, Jeff Thompson + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.IO; +using System.Collections; +using System.Collections.Generic; +using System.Text; +using System.CodeDom.Compiler; + +namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog +{ + public class YPCompiler + { + private class CompilerState + { + public IndexedAnswers _pred = new IndexedAnswers(); + public Dictionary _moduleForNameArity = new Dictionary(); + public int _gensymCounter; + public bool _useFinalCutCode; + public Variable _finalCutCode; + public bool _codeUsesYield; + public Atom _determinism; + // a list of '='(Name, Variable) + public List _variableNames; + + // Make these static functions that explicitly take the State so Prolog can call it. + + /// + /// Make a new CompilerState and bind it to State. + /// + /// + /// + public static IEnumerable make(object State) + { + return YP.unify(State, new CompilerState()); + } + + public static void assertPred(object State, object Pred, object Determinism) + { + State = YP.getValue(State); + object functorName = YP.getFunctorName(Pred); + object[] functorArgs = YP.getFunctorArgs(Pred); + // Debug: Should check if it's already asserted and is the same. + ((CompilerState)State)._pred.addAnswer + (new object[] { functorName, functorArgs.Length, Pred, YP.getValue(Determinism) }); + } + + public static void assertModuleForNameArity(object State, object Name, object Arity, object Module) + { + State = YP.getValue(State); + Name = YP.getValue(Name); + Arity = YP.getValue(Arity); + Module = YP.getValue(Module); + // If the Module Atom comes from the parser, it always has null _declaringClass. + if (Module is Atom && ((Atom)Module)._module == null && Name is Atom && Arity is int) + { + // Replace a previous entry if it exists. + ((CompilerState)State)._moduleForNameArity[new YP.NameArity((Atom)Name, (int)Arity)] = + (Atom)Module; + } + } + + public static void startFunction(object State, object Head) + { + State = YP.getValue(State); + ((CompilerState)State)._gensymCounter = 0; + ((CompilerState)State)._useFinalCutCode = false; + ((CompilerState)State)._finalCutCode = new Variable(); + ((CompilerState)State)._codeUsesYield = false; + if (CompilerState.isDetNoneOut(State, Head)) + ((CompilerState)State)._determinism = Atom.a("detNoneOut"); + else if (CompilerState.isSemidetNoneOut(State, Head)) + ((CompilerState)State)._determinism = Atom.a("semidetNoneOut"); + else + ((CompilerState)State)._determinism = Atom.a("nondet"); + } + + public static void setCodeUsesYield(object State) + { + State = YP.getValue(State); + ((CompilerState)State)._codeUsesYield = true; + } + + public static bool codeUsesYield(object State) + { + State = YP.getValue(State); + return ((CompilerState)State)._codeUsesYield; + } + + public static bool determinismEquals(object State, object Term) + { + State = YP.getValue(State); + return YP.termEqual(((CompilerState)State)._determinism, Term); + } + + /// + /// Set _variableNames to a new list of (Name = Variable) for each unique variable in rule. + /// If the variable is in variableNameSuggestions, use it, otherwise use x1, x2, etc. + /// + /// + /// + /// + public static void newVariableNames(object State, object Rule, object VariableNameSuggestions) + { + State = YP.getValue(State); + List variablesSet = new List(); + YP.addUniqueVariables(Rule, variablesSet); + + ((CompilerState)State)._variableNames = new List(); + int xCounter = 0; + foreach (Variable variable in variablesSet) + ((CompilerState)State)._variableNames.Add + (new Functor2(Atom.a("="), makeVariableName(variable, VariableNameSuggestions, ++xCounter), + variable)); + } + + private static object makeVariableName(object variable, object variableNameSuggestions, int xCounter) + { + // Debug: should require named variables to start with _ or capital. Should + // check for duplicates and clashes with keywords. + for (object element = YP.getValue(variableNameSuggestions); + element is Functor2 && ((Functor2)element)._name == Atom.DOT; + element = YP.getValue(((Functor2)element)._arg2)) + { + object suggestionPair = YP.getValue(((Functor2)element)._arg1); + if (sameVariable(variable, ((Functor2)suggestionPair)._arg2)) + { + Atom suggestion = (Atom)YP.getValue(((Functor2)suggestionPair)._arg1); + if (suggestion.Equals(Atom.a("Atom"))) + suggestion = Atom.a("Atom_1"); + if (suggestion.Equals(Atom.a("Variable"))) + suggestion = Atom.a("Variable_1"); + if (suggestion.Equals(Atom.a("Functor"))) + suggestion = Atom.a("Functor_1"); + return suggestion; + } + } + + return Atom.a("x" + xCounter); + } + + /// + /// Unify Result with the name assigned by CompilerState.newVariableNames in State._variableNames + /// for variable. + /// + /// a Variable + /// + /// the assigned Name + public static IEnumerable getVariableName(object State, object variable, object Result) + { + State = YP.getValue(State); + foreach (object variableInfo in ((CompilerState)State)._variableNames) + { + if (variableInfo is Functor2 && ((Functor2)variableInfo)._name.Equals(Atom.a("="))) + { + if (sameVariable(variable, ((Functor2)variableInfo)._arg2)) + return YP.unify(Result, ((Functor2)variableInfo)._arg1); + } + } + + // We set up names for all unique variables, so this should never happen. + throw new PrologException(Atom.a("Can't find entry in _variableNames")); + } + + public static IEnumerable variableNamesList(object State, object VariableNamesList) + { + State = YP.getValue(State); + return YP.unify(VariableNamesList, ListPair.make(((CompilerState)State)._variableNames)); + } + + public static IEnumerable gensym(object State, object Base, object Symbol) + { + State = YP.getValue(State); + return YP.unify(Symbol, Atom.a(Base.ToString() + ++((CompilerState)State)._gensymCounter)); + } + + public static bool isDetNoneOut(object State, object Term) + { + State = YP.getValue(State); + object functorName = YP.getFunctorName(Term); + object[] functorArgs = YP.getFunctorArgs(Term); + + Variable pred = new Variable(); + foreach (bool l1 in ((CompilerState)State)._pred.match + (new object[] { functorName, functorArgs.Length, pred, Atom.a("det") })) + { + if (CompilerState.isNoneOut(YP.getFunctorArgs(pred.getValue()))) + { + return true; + } + } + + return false; + } + + public static bool isSemidetNoneOut(object State, object Term) + { + State = YP.getValue(State); + object functorName = YP.getFunctorName(Term); + object[] functorArgs = YP.getFunctorArgs(Term); + + Variable pred = new Variable(); + foreach (bool l1 in ((CompilerState)State)._pred.match + (new object[] { functorName, functorArgs.Length, pred, Atom.a("semidet") })) + { + if (CompilerState.isNoneOut(YP.getFunctorArgs(pred.getValue()))) + { + return true; + } + } + + return false; + } + + /// + /// Return false if any of args is out, otherwise true. + /// args is an array of ::(Type,Mode) where Mode is in or out. + /// + /// + /// + private static bool isNoneOut(object[] args) + { + foreach (object arg in args) + { + if (arg is Functor2 && ((Functor2)arg)._name == Atom.a("::") && + ((Functor2)arg)._arg2 == Atom.a("out")) + return false; + } + return true; + } + + public static bool nameArityHasModule(object State, object Name, object Arity, object Module) + { + State = YP.getValue(State); + Name = YP.getValue(Name); + Arity = YP.getValue(Arity); + Module = YP.getValue(Module); + if (Name is Atom && Arity is int) + { + Atom FoundModule; + if (!((CompilerState)State)._moduleForNameArity.TryGetValue + (new YP.NameArity((Atom)Name, (int)Arity), out FoundModule)) + return false; + return FoundModule == Module; + } + return false; + } + } + + /// + /// Use makeFunctionPseudoCode, convertFunctionCSharp and compileAnonymousFunction + /// to return an anonymous YP.IClause for the Head and Body of a rule clause. + /// + /// a prolog term such as new Functor2("test1", X, Y). + /// Note that the name of the head is ignored. + /// + /// a prolog term such as + /// new Functor2(",", new Functor1(Atom.a("test2", Atom.a("")), X), + /// new Functor2("=", Y, X)). + /// This may not be null. (For a head-only clause, set the Body to Atom.a("true"). + /// + /// if not null, the code is compiled as a subclass of this class + /// to resolve references to the default module Atom.a("") + /// a new YP.IClause object on which you can call match(object[] args) where + /// args length is the arity of the Head + public static YP.IClause compileAnonymousClause(object Head, object Body, Type declaringClass) + { + object[] args = YP.getFunctorArgs(Head); + // compileAnonymousFunction wants "function". + object Rule = new Functor2(Atom.RULE, Functor.make("function", args), Body); + object RuleList = ListPair.make(new Functor2(Atom.F, Rule, Atom.NIL)); + + StringWriter functionCode = new StringWriter(); + Variable SaveOutputStream = new Variable(); + foreach (bool l1 in YP.current_output(SaveOutputStream)) + { + try + { + YP.tell(functionCode); + Variable FunctionCode = new Variable(); + foreach (bool l2 in makeFunctionPseudoCode(RuleList, FunctionCode)) + { + if (YP.termEqual(FunctionCode, Atom.a("getDeclaringClass"))) + // Ignore getDeclaringClass since we have access to the one passed in. + continue; + + // Debug: should check if FunctionCode is a single call. + convertFunctionCSharp(FunctionCode); + } + YP.told(); + } + finally + { + // Restore after calling tell. + YP.tell(SaveOutputStream.getValue()); + } + } + return YPCompiler.compileAnonymousFunction + (functionCode.ToString(), args.Length, declaringClass); + } + + /// + /// Use CodeDomProvider to compile the functionCode and return a YP.IClause. + /// The function name must be "function" and have nArgs arguments. + /// + /// the code for the iterator, such as + /// "public static IEnumerable function() { yield return false; }" + /// + /// the number of args in the function + /// if not null, then use the functionCode inside a class which + /// inherits from contextClass, so that references in functionCode to methods in declaringClass don't + /// have to be qualified + /// a new YP.IClause object on which you can call match(object[] args) where + /// args length is nArgs + public static YP.IClause compileAnonymousFunction(string functionCode, int nArgs, Type declaringClass) + { + CompilerParameters parameters = new CompilerParameters(); + // This gets the location of the System assembly. + parameters.ReferencedAssemblies.Add(typeof(System.Int32).Assembly.Location); + // This gets the location of this assembly which also has YieldProlog.YP, etc. + parameters.ReferencedAssemblies.Add(typeof(YPCompiler).Assembly.Location); + if (declaringClass != null) + parameters.ReferencedAssemblies.Add(declaringClass.Assembly.Location); + parameters.GenerateInMemory = true; + + StringBuilder sourceCode = new StringBuilder(); + sourceCode.Append(@" +using System; +using System.Collections.Generic; +using YieldProlog; + +namespace Temporary { + public class Temporary : YP.IClause { + public class Inner" + (declaringClass == null ? "" : " : " + declaringClass.FullName) + @" { +"); + sourceCode.Append(functionCode); + // Basically, match applies the args to function. + sourceCode.Append(@" + } + public IEnumerable match(object[] args) { + return Inner.function("); + if (nArgs >= 1) + sourceCode.Append("args[0]"); + for (int i = 1; i < nArgs; ++i) + sourceCode.Append(", args[" + i + "]"); + sourceCode.Append(@"); + } + } +} +"); + + CompilerResults results = CodeDomProvider.CreateProvider + ("CSharp").CompileAssemblyFromSource(parameters, sourceCode.ToString()); + if (results.Errors.Count > 0) + throw new Exception("Error evaluating code: " + results.Errors[0]); + + // Return a new Temporary.Temporary object. + return (YP.IClause)results.CompiledAssembly.GetType + ("Temporary.Temporary").GetConstructor(Type.EmptyTypes).Invoke(null); + } + + // Compiler output follows. + + public class YPInnerClass { } + public static System.Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; } + + public static void repeatWrite(object arg1, object N) + { + { + object _Value = arg1; + if (YP.termEqual(N, 0)) + { + return; + } + } + { + object Value = arg1; + Variable NextN = new Variable(); + YP.write(Value); + foreach (bool l2 in YP.unify(NextN, YP.subtract(N, 1))) + { + repeatWrite(Value, NextN); + return; + } + } + } + + public static bool sameVariable(object Variable1, object Variable2) + { + { + if (YP.var(Variable1)) + { + if (YP.var(Variable2)) + { + if (YP.termEqual(Variable1, Variable2)) + { + return true; + } + } + } + } + return false; + } + + public static IEnumerable makeFunctionPseudoCode(object RuleList, object FunctionCode) + { + { + Variable State = new Variable(); + foreach (bool l2 in CompilerState.make(State)) + { + CompilerState.assertPred(State, Atom.a(@"nl"), Atom.a(@"det")); + CompilerState.assertPred(State, new Functor1(@"write", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"det")); + CompilerState.assertPred(State, new Functor1(@"put_code", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"det")); + CompilerState.assertPred(State, new Functor1(@"throw", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"det")); + CompilerState.assertPred(State, new Functor1(@"var", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor1(@"nonvar", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor1(@"atom", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor1(@"integer", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor1(@"float", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor1(@"number", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor1(@"atomic", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor1(@"compound", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor2(@"==", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor2(@"\==", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor2(@"@<", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor2(@"@=<", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor2(@"@>", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor2(@"@>=", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + processCompilerDirectives(RuleList, State); + foreach (bool l3 in YP.unify(FunctionCode, Atom.a(@"getDeclaringClass"))) + { + yield return false; + } + foreach (bool l3 in makeFunctionPseudoCode3(RuleList, State, FunctionCode)) + { + yield return false; + } + } + } + } + + public static void processCompilerDirectives(object arg1, object arg2) + { + { + object _State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + object State = arg2; + Variable Pred = new Variable(); + Variable Determinism = new Variable(); + Variable x3 = new Variable(); + Variable RestRules = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor1(@":-", new Functor1(@"pred", new Functor2(@"is", Pred, Determinism))), x3), RestRules))) + { + CompilerState.assertPred(State, Pred, Determinism); + processCompilerDirectives(RestRules, State); + return; + } + } + { + object State = arg2; + Variable Module = new Variable(); + Variable PredicateList = new Variable(); + Variable x3 = new Variable(); + Variable RestRules = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor1(@":-", new Functor2(@"import", Module, PredicateList)), x3), RestRules))) + { + foreach (bool l3 in importPredicateList(State, Module, PredicateList)) + { + processCompilerDirectives(RestRules, State); + return; + } + } + } + { + object State = arg2; + Variable x1 = new Variable(); + Variable x2 = new Variable(); + Variable RestRules = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor1(@":-", x1), x2), RestRules))) + { + processCompilerDirectives(RestRules, State); + return; + } + } + { + object State = arg2; + Variable Head = new Variable(); + Variable _Body = new Variable(); + Variable x3 = new Variable(); + Variable RestRules = new Variable(); + Variable Name = new Variable(); + Variable Arity = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor2(@":-", Head, _Body), x3), RestRules))) + { + foreach (bool l3 in YP.functor(Head, Name, Arity)) + { + CompilerState.assertModuleForNameArity(State, Name, Arity, Atom.a(@"")); + processCompilerDirectives(RestRules, State); + return; + } + } + } + { + object State = arg2; + Variable Fact = new Variable(); + Variable x2 = new Variable(); + Variable RestRules = new Variable(); + Variable Name = new Variable(); + Variable Arity = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", Fact, x2), RestRules))) + { + foreach (bool l3 in YP.functor(Fact, Name, Arity)) + { + CompilerState.assertModuleForNameArity(State, Name, Arity, Atom.a(@"")); + processCompilerDirectives(RestRules, State); + return; + } + } + } + { + object State = arg2; + Variable x1 = new Variable(); + Variable RestRules = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(x1, RestRules))) + { + processCompilerDirectives(RestRules, State); + return; + } + } + } + + public static IEnumerable importPredicateList(object arg1, object arg2, object arg3) + { + { + object _State = arg1; + object _Module = arg2; + foreach (bool l2 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + { + object State = arg1; + object Module = arg2; + Variable Name = new Variable(); + Variable Arity = new Variable(); + Variable Rest = new Variable(); + foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor2(@"/", Name, Arity), Rest))) + { + CompilerState.assertModuleForNameArity(State, Name, Arity, Module); + foreach (bool l3 in importPredicateList(State, Module, Rest)) + { + yield return true; + yield break; + } + } + } + { + object State = arg1; + object Module = arg2; + Variable x3 = new Variable(); + Variable Rest = new Variable(); + foreach (bool l2 in YP.unify(arg3, new ListPair(x3, Rest))) + { + foreach (bool l3 in importPredicateList(State, Module, Rest)) + { + yield return true; + yield break; + } + } + } + } + + public static IEnumerable makeFunctionPseudoCode3(object RuleList, object State, object FunctionCode) + { + { + Variable SamePredicateRuleList = new Variable(); + Variable RestRules = new Variable(); + foreach (bool l2 in samePredicateRuleList(RuleList, SamePredicateRuleList, RestRules)) + { + if (YP.termNotEqual(SamePredicateRuleList, Atom.NIL)) + { + foreach (bool l4 in compileSamePredicateFunction(SamePredicateRuleList, State, FunctionCode)) + { + yield return false; + } + foreach (bool l4 in makeFunctionPseudoCode3(RestRules, State, FunctionCode)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable compileSamePredicateFunction(object SamePredicateRuleList, object State, object FunctionCode) + { + { + Variable FirstRule = new Variable(); + Variable x5 = new Variable(); + Variable x6 = new Variable(); + Variable x7 = new Variable(); + Variable Head = new Variable(); + Variable x9 = new Variable(); + Variable ArgAssignments = new Variable(); + Variable Calls = new Variable(); + Variable Rule = new Variable(); + Variable VariableNameSuggestions = new Variable(); + Variable ClauseBag = new Variable(); + Variable Name = new Variable(); + Variable ArgsList = new Variable(); + Variable FunctionArgNames = new Variable(); + Variable MergedArgName = new Variable(); + Variable ArgName = new Variable(); + Variable MergedArgNames = new Variable(); + Variable FunctionArgs = new Variable(); + Variable BodyCode = new Variable(); + Variable ReturnType = new Variable(); + Variable BodyWithReturn = new Variable(); + foreach (bool l2 in YP.unify(new ListPair(new Functor2(@"f", FirstRule, x5), x6), SamePredicateRuleList)) + { + foreach (bool l3 in YP.unify(FirstRule, new Functor1(@":-", x7))) + { + goto cutIf1; + } + foreach (bool l3 in YP.unify(new Functor2(@":-", Head, x9), FirstRule)) + { + CompilerState.startFunction(State, Head); + FindallAnswers findallAnswers3 = new FindallAnswers(new Functor2(@"f", ArgAssignments, Calls)); + foreach (bool l4 in member(new Functor2(@"f", Rule, VariableNameSuggestions), SamePredicateRuleList)) + { + foreach (bool l5 in compileBodyWithHeadBindings(Rule, VariableNameSuggestions, State, ArgAssignments, Calls)) + { + findallAnswers3.add(); + } + } + foreach (bool l4 in findallAnswers3.result(ClauseBag)) + { + foreach (bool l5 in YP.univ(Head, new ListPair(Name, ArgsList))) + { + foreach (bool l6 in getFunctionArgNames(ArgsList, 1, FunctionArgNames)) + { + FindallAnswers findallAnswers4 = new FindallAnswers(MergedArgName); + foreach (bool l7 in member(ArgName, FunctionArgNames)) + { + foreach (bool l8 in argAssignedAll(ArgName, ClauseBag, MergedArgName)) + { + findallAnswers4.add(); + goto cutIf5; + } + foreach (bool l8 in YP.unify(MergedArgName, ArgName)) + { + findallAnswers4.add(); + } + cutIf5: + { } + } + foreach (bool l7 in findallAnswers4.result(MergedArgNames)) + { + foreach (bool l8 in maplist_arg(MergedArgNames, FunctionArgs)) + { + foreach (bool l9 in maplist_compileClause(ClauseBag, MergedArgNames, BodyCode)) + { + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"void"))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf7; + } + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf8; + } + if (CompilerState.codeUsesYield(State)) + { + foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf9; + } + foreach (bool l12 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + cutIf9: + cutIf8: + cutIf7: + { } + } + goto cutIf6; + } + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"bool"))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf11; + } + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf12; + } + if (CompilerState.codeUsesYield(State)) + { + foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf13; + } + foreach (bool l12 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + cutIf13: + cutIf12: + cutIf11: + { } + } + goto cutIf10; + } + foreach (bool l10 in YP.unify(ReturnType, Atom.a(@"IEnumerable"))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l12 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf14; + } + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf15; + } + if (CompilerState.codeUsesYield(State)) + { + foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf16; + } + foreach (bool l11 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn)) + { + foreach (bool l12 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + cutIf16: + cutIf15: + cutIf14: + { } + } + cutIf10: + cutIf6: + { } + } + } + } + } + } + } + goto cutIf2; + } + foreach (bool l3 in YP.unify(Head, FirstRule)) + { + CompilerState.startFunction(State, Head); + FindallAnswers findallAnswers17 = new FindallAnswers(new Functor2(@"f", ArgAssignments, Calls)); + foreach (bool l4 in member(new Functor2(@"f", Rule, VariableNameSuggestions), SamePredicateRuleList)) + { + foreach (bool l5 in compileBodyWithHeadBindings(Rule, VariableNameSuggestions, State, ArgAssignments, Calls)) + { + findallAnswers17.add(); + } + } + foreach (bool l4 in findallAnswers17.result(ClauseBag)) + { + foreach (bool l5 in YP.univ(Head, new ListPair(Name, ArgsList))) + { + foreach (bool l6 in getFunctionArgNames(ArgsList, 1, FunctionArgNames)) + { + FindallAnswers findallAnswers18 = new FindallAnswers(MergedArgName); + foreach (bool l7 in member(ArgName, FunctionArgNames)) + { + foreach (bool l8 in argAssignedAll(ArgName, ClauseBag, MergedArgName)) + { + findallAnswers18.add(); + goto cutIf19; + } + foreach (bool l8 in YP.unify(MergedArgName, ArgName)) + { + findallAnswers18.add(); + } + cutIf19: + { } + } + foreach (bool l7 in findallAnswers18.result(MergedArgNames)) + { + foreach (bool l8 in maplist_arg(MergedArgNames, FunctionArgs)) + { + foreach (bool l9 in maplist_compileClause(ClauseBag, MergedArgNames, BodyCode)) + { + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"void"))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf21; + } + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf22; + } + if (CompilerState.codeUsesYield(State)) + { + foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf23; + } + foreach (bool l12 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + cutIf23: + cutIf22: + cutIf21: + { } + } + goto cutIf20; + } + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"bool"))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf25; + } + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf26; + } + if (CompilerState.codeUsesYield(State)) + { + foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf27; + } + foreach (bool l12 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + cutIf27: + cutIf26: + cutIf25: + { } + } + goto cutIf24; + } + foreach (bool l10 in YP.unify(ReturnType, Atom.a(@"IEnumerable"))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l12 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf28; + } + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf29; + } + if (CompilerState.codeUsesYield(State)) + { + foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf30; + } + foreach (bool l11 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn)) + { + foreach (bool l12 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + cutIf30: + cutIf29: + cutIf28: + { } + } + cutIf24: + cutIf20: + { } + } + } + } + } + } + } + } + cutIf2: + cutIf1: + { } + } + } + } + + public static IEnumerable samePredicateRuleList(object arg1, object arg2, object arg3) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + foreach (bool l4 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + } + { + Variable First = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(First, Atom.NIL))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(First, Atom.NIL))) + { + foreach (bool l4 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + } + { + object SamePredicateRuleList = arg2; + object RestRules = arg3; + Variable First = new Variable(); + Variable Rest = new Variable(); + Variable FirstRule = new Variable(); + Variable x6 = new Variable(); + Variable SecondRule = new Variable(); + Variable x8 = new Variable(); + Variable x9 = new Variable(); + Variable FirstHead = new Variable(); + Variable x11 = new Variable(); + Variable SecondHead = new Variable(); + Variable x13 = new Variable(); + Variable Name = new Variable(); + Variable Arity = new Variable(); + Variable RestSamePredicates = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) + { + foreach (bool l3 in YP.unify(new Functor2(@"f", FirstRule, x6), First)) + { + foreach (bool l4 in YP.unify(new ListPair(new Functor2(@"f", SecondRule, x8), x9), Rest)) + { + foreach (bool l5 in YP.unify(new Functor2(@":-", FirstHead, x11), FirstRule)) + { + foreach (bool l6 in YP.unify(new Functor2(@":-", SecondHead, x13), SecondRule)) + { + foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) + { + foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) + { + foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) + { + foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) + { + yield return true; + yield break; + } + } + goto cutIf3; + } + foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) + { + foreach (bool l9 in YP.unify(RestRules, Rest)) + { + yield return true; + yield break; + } + } + cutIf3: + { } + } + goto cutIf2; + } + foreach (bool l6 in YP.unify(SecondHead, SecondRule)) + { + foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) + { + foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) + { + foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) + { + foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) + { + yield return true; + yield break; + } + } + goto cutIf4; + } + foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) + { + foreach (bool l9 in YP.unify(RestRules, Rest)) + { + yield return true; + yield break; + } + } + cutIf4: + { } + } + } + cutIf2: + goto cutIf1; + } + foreach (bool l5 in YP.unify(FirstHead, FirstRule)) + { + foreach (bool l6 in YP.unify(new Functor2(@":-", SecondHead, x13), SecondRule)) + { + foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) + { + foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) + { + foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) + { + foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) + { + yield return true; + yield break; + } + } + goto cutIf6; + } + foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) + { + foreach (bool l9 in YP.unify(RestRules, Rest)) + { + yield return true; + yield break; + } + } + cutIf6: + { } + } + goto cutIf5; + } + foreach (bool l6 in YP.unify(SecondHead, SecondRule)) + { + foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) + { + foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) + { + foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) + { + foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) + { + yield return true; + yield break; + } + } + goto cutIf7; + } + foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) + { + foreach (bool l9 in YP.unify(RestRules, Rest)) + { + yield return true; + yield break; + } + } + cutIf7: + { } + } + } + cutIf5: + { } + } + cutIf1: + { } + } + } + } + } + } + + public static IEnumerable maplist_compileClause(object arg1, object arg2, object arg3) + { + { + object _MergedArgNames = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + object MergedArgNames = arg2; + Variable ArgAssignments = new Variable(); + Variable Calls = new Variable(); + Variable Rest = new Variable(); + Variable ClauseCode = new Variable(); + Variable RestResults = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", ArgAssignments, Calls), Rest))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1(@"blockScope", ClauseCode), RestResults))) + { + foreach (bool l4 in prependArgAssignments(ArgAssignments, Calls, MergedArgNames, ClauseCode)) + { + foreach (bool l5 in maplist_compileClause(Rest, MergedArgNames, RestResults)) + { + yield return true; + yield break; + } + } + } + } + } + } + + public static IEnumerable prependArgAssignments(object arg1, object arg2, object arg3, object arg4) + { + { + object _MergedArgNames = arg3; + Variable In = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, In)) + { + foreach (bool l4 in YP.unify(arg4, In)) + { + yield return true; + yield break; + } + } + } + } + { + object In = arg2; + object MergedArgNames = arg3; + object ClauseCode = arg4; + Variable VariableName = new Variable(); + Variable ArgName = new Variable(); + Variable RestArgAssignments = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", VariableName, ArgName), RestArgAssignments))) + { + foreach (bool l3 in member(VariableName, MergedArgNames)) + { + foreach (bool l4 in prependArgAssignments(RestArgAssignments, In, MergedArgNames, ClauseCode)) + { + yield return true; + yield break; + } + goto cutIf1; + } + foreach (bool l3 in prependArgAssignments(RestArgAssignments, new ListPair(new Functor3(@"declare", Atom.a(@"object"), VariableName, new Functor1(@"var", ArgName)), In), MergedArgNames, ClauseCode)) + { + yield return true; + yield break; + } + cutIf1: + { } + } + } + } + + public static IEnumerable argAssignedAll(object arg1, object arg2, object VariableName) + { + { + object _ArgName = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.NIL)) + { + if (YP.nonvar(VariableName)) + { + yield return true; + yield break; + } + } + } + { + object ArgName = arg1; + Variable ArgAssignments = new Variable(); + Variable _Calls = new Variable(); + Variable RestClauseBag = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(new Functor2(@"f", ArgAssignments, _Calls), RestClauseBag))) + { + foreach (bool l3 in member(new Functor2(@"f", VariableName, ArgName), ArgAssignments)) + { + foreach (bool l4 in argAssignedAll(ArgName, RestClauseBag, VariableName)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable maplist_arg(object arg1, object arg2) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + Variable First = new Variable(); + Variable Rest = new Variable(); + Variable RestResults = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor1(@"arg", First), RestResults))) + { + foreach (bool l4 in maplist_arg(Rest, RestResults)) + { + yield return true; + yield break; + } + } + } + } + } + + public static IEnumerable getFunctionArgNames(object arg1, object arg2, object arg3) + { + { + object _StartArgNumber = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + object StartArgNumber = arg2; + Variable x1 = new Variable(); + Variable Rest = new Variable(); + Variable ArgName = new Variable(); + Variable RestFunctionArgs = new Variable(); + Variable NumberCodes = new Variable(); + Variable NumberAtom = new Variable(); + Variable NextArgNumber = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(x1, Rest))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(ArgName, RestFunctionArgs))) + { + foreach (bool l4 in YP.number_codes(StartArgNumber, NumberCodes)) + { + foreach (bool l5 in YP.atom_codes(NumberAtom, NumberCodes)) + { + foreach (bool l6 in YP.atom_concat(Atom.a(@"arg"), NumberAtom, ArgName)) + { + foreach (bool l7 in YP.unify(NextArgNumber, YP.add(StartArgNumber, 1))) + { + foreach (bool l8 in getFunctionArgNames(Rest, NextArgNumber, RestFunctionArgs)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + } + + public static IEnumerable compileBodyWithHeadBindings(object Rule, object VariableNameSuggestions, object State, object ArgAssignments, object Calls) + { + { + Variable Head = new Variable(); + Variable Body = new Variable(); + Variable x8 = new Variable(); + Variable HeadArgs = new Variable(); + Variable CompiledHeadArgs = new Variable(); + Variable BodyCode = new Variable(); + Variable VariableNamesList = new Variable(); + Variable ArgUnifications = new Variable(); + foreach (bool l2 in YP.unify(new Functor2(@":-", Head, Body), Rule)) + { + CompilerState.newVariableNames(State, Rule, VariableNameSuggestions); + foreach (bool l3 in YP.univ(Head, new ListPair(x8, HeadArgs))) + { + foreach (bool l4 in maplist_compileTerm(HeadArgs, State, CompiledHeadArgs)) + { + foreach (bool l5 in compileRuleBody(Body, State, BodyCode)) + { + foreach (bool l6 in CompilerState.variableNamesList(State, VariableNamesList)) + { + foreach (bool l7 in compileArgUnifications(HeadArgs, CompiledHeadArgs, 1, HeadArgs, BodyCode, ArgUnifications)) + { + foreach (bool l8 in compileDeclarations(VariableNamesList, HeadArgs, Atom.NIL, ArgAssignments, ArgUnifications, Calls)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + { + foreach (bool l2 in compileBodyWithHeadBindings(new Functor2(@":-", Rule, Atom.a(@"true")), VariableNameSuggestions, State, ArgAssignments, Calls)) + { + yield return true; + yield break; + } + } + } + + public static IEnumerable compileArgUnifications(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) + { + { + object x1 = arg2; + object x2 = arg3; + object x3 = arg4; + Variable BodyCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg5, BodyCode)) + { + foreach (bool l4 in YP.unify(arg6, BodyCode)) + { + yield return true; + yield break; + } + } + } + } + { + object Index = arg3; + object AllHeadArgs = arg4; + object BodyCode = arg5; + object ArgUnifications = arg6; + Variable HeadArg = new Variable(); + Variable RestHeadArgs = new Variable(); + Variable x3 = new Variable(); + Variable RestCompiledHeadArgs = new Variable(); + Variable _ArgIndex1 = new Variable(); + Variable NextIndex = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(HeadArg, RestHeadArgs))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(x3, RestCompiledHeadArgs))) + { + foreach (bool l4 in getVariableArgIndex1(HeadArg, AllHeadArgs, _ArgIndex1)) + { + foreach (bool l5 in YP.unify(NextIndex, YP.add(Index, 1))) + { + foreach (bool l6 in compileArgUnifications(RestHeadArgs, RestCompiledHeadArgs, NextIndex, AllHeadArgs, BodyCode, ArgUnifications)) + { + yield return true; + yield break; + } + } + } + } + } + } + { + object Index = arg3; + object AllHeadArgs = arg4; + object BodyCode = arg5; + Variable _HeadArg = new Variable(); + Variable RestHeadArgs = new Variable(); + Variable CompiledHeadArg = new Variable(); + Variable RestCompiledHeadArgs = new Variable(); + Variable ArgName = new Variable(); + Variable RestArgUnifications = new Variable(); + Variable NumberCodes = new Variable(); + Variable NumberAtom = new Variable(); + Variable NextIndex = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(_HeadArg, RestHeadArgs))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(CompiledHeadArg, RestCompiledHeadArgs))) + { + foreach (bool l4 in YP.unify(arg6, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.unify"), new ListPair(new Functor1(@"var", ArgName), new ListPair(CompiledHeadArg, Atom.NIL))), RestArgUnifications), Atom.NIL))) + { + foreach (bool l5 in YP.number_codes(Index, NumberCodes)) + { + foreach (bool l6 in YP.atom_codes(NumberAtom, NumberCodes)) + { + foreach (bool l7 in YP.atom_concat(Atom.a(@"arg"), NumberAtom, ArgName)) + { + foreach (bool l8 in YP.unify(NextIndex, YP.add(Index, 1))) + { + foreach (bool l9 in compileArgUnifications(RestHeadArgs, RestCompiledHeadArgs, NextIndex, AllHeadArgs, BodyCode, RestArgUnifications)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + } + } + + public static IEnumerable compileDeclarations(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) + { + { + object _HeadArgs = arg2; + Variable ArgAssignmentsIn = new Variable(); + Variable DeclarationsIn = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg3, ArgAssignmentsIn)) + { + foreach (bool l4 in YP.unify(arg4, ArgAssignmentsIn)) + { + foreach (bool l5 in YP.unify(arg5, DeclarationsIn)) + { + foreach (bool l6 in YP.unify(arg6, DeclarationsIn)) + { + yield return true; + yield break; + } + } + } + } + } + } + { + object HeadArgs = arg2; + object ArgAssignmentsIn = arg3; + object ArgAssignmentsOut = arg4; + object DeclarationsIn = arg5; + object DeclarationsOut = arg6; + Variable VariableName = new Variable(); + Variable Var = new Variable(); + Variable RestVariableNames = new Variable(); + Variable ArgIndex1 = new Variable(); + Variable NumberCodes = new Variable(); + Variable NumberAtom = new Variable(); + Variable ArgName = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"=", VariableName, Var), RestVariableNames))) + { + foreach (bool l3 in getVariableArgIndex1(Var, HeadArgs, ArgIndex1)) + { + foreach (bool l4 in YP.number_codes(ArgIndex1, NumberCodes)) + { + foreach (bool l5 in YP.atom_codes(NumberAtom, NumberCodes)) + { + foreach (bool l6 in YP.atom_concat(Atom.a(@"arg"), NumberAtom, ArgName)) + { + foreach (bool l7 in compileDeclarations(RestVariableNames, HeadArgs, new ListPair(new Functor2(@"f", VariableName, ArgName), ArgAssignmentsIn), ArgAssignmentsOut, DeclarationsIn, DeclarationsOut)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + { + object HeadArgs = arg2; + object ArgAssignmentsIn = arg3; + object ArgAssignmentsOut = arg4; + object DeclarationsIn = arg5; + Variable VariableName = new Variable(); + Variable _Var = new Variable(); + Variable RestVariableNames = new Variable(); + Variable DeclarationsOut = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"=", VariableName, _Var), RestVariableNames))) + { + foreach (bool l3 in YP.unify(arg6, new ListPair(new Functor3(@"declare", Atom.a(@"Variable"), VariableName, new Functor2(@"new", Atom.a(@"Variable"), Atom.NIL)), DeclarationsOut))) + { + foreach (bool l4 in compileDeclarations(RestVariableNames, HeadArgs, ArgAssignmentsIn, ArgAssignmentsOut, DeclarationsIn, DeclarationsOut)) + { + yield return true; + yield break; + } + } + } + } + } + + public static IEnumerable getVariableArgIndex1(object Var, object arg2, object arg3) + { + { + Variable FirstHeadArgs = new Variable(); + Variable RestHeadArgs = new Variable(); + Variable x4 = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(FirstHeadArgs, RestHeadArgs))) + { + foreach (bool l3 in YP.unify(arg3, 1)) + { + if (sameVariable(Var, FirstHeadArgs)) + { + foreach (bool l5 in getVariableArgIndex1(Var, RestHeadArgs, x4)) + { + goto cutIf1; + } + yield return false; + cutIf1: + yield break; + } + } + } + } + { + object Index = arg3; + Variable x2 = new Variable(); + Variable RestHeadArgs = new Variable(); + Variable RestIndex = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(x2, RestHeadArgs))) + { + foreach (bool l3 in getVariableArgIndex1(Var, RestHeadArgs, RestIndex)) + { + foreach (bool l4 in YP.unify(Index, YP.add(1, RestIndex))) + { + yield return true; + yield break; + } + } + } + } + } + + public static IEnumerable compileRuleBody(object arg1, object arg2, object arg3) + { + { + object A = arg1; + object State = arg2; + object PseudoCode = arg3; + if (YP.var(A)) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor1(@"call", A), Atom.a(@"true")), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"!"))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"return"), Atom.NIL))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"!"))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"returntrue"), Atom.NIL))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"!"))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"yieldtrue"), new ListPair(Atom.a(@"yieldbreak"), Atom.NIL)))) + { + CompilerState.setCodeUsesYield(State); + yield return true; + yield break; + } + } + } + { + object _State = arg2; + Variable Name = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"$CUTIF", Name))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1(@"breakBlock", Name), Atom.NIL))) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"true"))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"return"), Atom.NIL))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"true"))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"returntrue"), Atom.NIL))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"true"))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"yieldfalse"), Atom.NIL))) + { + CompilerState.setCodeUsesYield(State); + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) + { + if (YP.var(A)) + { + foreach (bool l4 in compileRuleBody(new Functor2(@",", new Functor1(@"call", A), B), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable T = new Variable(); + Variable B = new Variable(); + Variable C = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, T), B), C))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@";", new Functor2(@"->", A, new Functor2(@",", T, C)), new Functor2(@",", B, C)), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + Variable C = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@";", A, B), C))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@";", new Functor2(@",", A, C), new Functor2(@",", B, C)), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ACode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"\+", A), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"if", new Functor1(@"not", ACode), BCode), Atom.NIL))) + { + if (CompilerState.isSemidetNoneOut(State, A)) + { + foreach (bool l5 in compileFunctorCall(A, State, ACode)) + { + foreach (bool l6 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"\+", A), B))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, Atom.a(@"fail")), Atom.a(@"true")), B), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"once", A), B))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, Atom.a(@"true")), Atom.a(@"fail")), B), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable T = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@"->", A, T), B))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, T), Atom.a(@"fail")), B), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + Variable C = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@"\=", A, B), C))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor1(@"\+", new Functor2(@"=", A, B)), C), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable ACode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", Atom.a(@"!"), A))) + { + foreach (bool l3 in compileRuleBody(A, State, ACode)) + { + foreach (bool l4 in append(ACode, new ListPair(Atom.a(@"yieldbreak"), Atom.NIL), PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable Name = new Variable(); + Variable A = new Variable(); + Variable ACode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"$CUTIF", Name), A))) + { + foreach (bool l3 in compileRuleBody(A, State, ACode)) + { + foreach (bool l4 in append(ACode, new ListPair(new Functor1(@"breakBlock", Name), Atom.NIL), PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + { + object _State = arg2; + Variable x1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", Atom.a(@"fail"), x1))) + { + foreach (bool l3 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", Atom.a(@"true"), A))) + { + foreach (bool l3 in compileRuleBody(A, State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable Term = new Variable(); + Variable B = new Variable(); + Variable ACode = new Variable(); + Variable TermCode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@"is", A, Term), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.unify"), new ListPair(ACode, new ListPair(TermCode, Atom.NIL))), BCode), Atom.NIL))) + { + foreach (bool l4 in compileTerm(A, State, ACode)) + { + foreach (bool l5 in compileExpression(Term, State, TermCode)) + { + foreach (bool l6 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ACode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(ACode, BCode))) + { + if (CompilerState.isDetNoneOut(State, A)) + { + foreach (bool l5 in compileFunctorCall(A, State, ACode)) + { + foreach (bool l6 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ACode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"if", ACode, BCode), Atom.NIL))) + { + if (CompilerState.isSemidetNoneOut(State, A)) + { + foreach (bool l5 in compileFunctorCall(A, State, ACode)) + { + foreach (bool l6 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + { + object State = arg2; + Variable ACode = new Variable(); + Variable B = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"$DET_NONE_OUT", ACode), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(ACode, BCode))) + { + foreach (bool l4 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable FunctionName = new Variable(); + Variable X1Code = new Variable(); + Variable X2Code = new Variable(); + Variable BCode = new Variable(); + Variable Name = new Variable(); + Variable X1 = new Variable(); + Variable X2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"if", new Functor2(@"call", FunctionName, new ListPair(X1Code, new ListPair(X2Code, Atom.NIL))), BCode), Atom.NIL))) + { + foreach (bool l4 in YP.univ(A, new ListPair(Name, new ListPair(X1, new ListPair(X2, Atom.NIL))))) + { + foreach (bool l5 in binaryExpressionConditional(Name, FunctionName)) + { + foreach (bool l6 in compileExpression(X1, State, X1Code)) + { + foreach (bool l7 in compileExpression(X2, State, X2Code)) + { + foreach (bool l8 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + Variable C = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@",", A, B), C))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", A, new Functor2(@",", B, C)), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable Template = new Variable(); + Variable Goal = new Variable(); + Variable Bag = new Variable(); + Variable B = new Variable(); + Variable TemplateCode = new Variable(); + Variable FindallAnswers = new Variable(); + Variable GoalAndAddCode = new Variable(); + Variable BagCode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"findall", Template, Goal, Bag), B))) + { + foreach (bool l3 in compileTerm(Template, State, TemplateCode)) + { + foreach (bool l4 in CompilerState.gensym(State, Atom.a(@"findallAnswers"), FindallAnswers)) + { + foreach (bool l5 in compileRuleBody(new Functor2(@",", Goal, new Functor2(@",", new Functor1(@"$DET_NONE_OUT", new Functor3(@"callMember", new Functor1(@"var", FindallAnswers), Atom.a(@"add"), Atom.NIL)), Atom.a(@"fail"))), State, GoalAndAddCode)) + { + foreach (bool l6 in compileTerm(Bag, State, BagCode)) + { + foreach (bool l7 in compileRuleBody(B, State, BCode)) + { + foreach (bool l8 in append(new ListPair(new Functor3(@"declare", Atom.a(@"FindallAnswers"), FindallAnswers, new Functor2(@"new", Atom.a(@"FindallAnswers"), new ListPair(TemplateCode, Atom.NIL))), GoalAndAddCode), new ListPair(new Functor2(@"foreach", new Functor3(@"callMember", new Functor1(@"var", FindallAnswers), Atom.a(@"result"), new ListPair(BagCode, Atom.NIL)), BCode), Atom.NIL), PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable Template = new Variable(); + Variable Goal = new Variable(); + Variable Bag = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"bagof", Template, Goal, Bag), B))) + { + foreach (bool l3 in compileBagof(Atom.a(@"result"), Template, Goal, Bag, B, State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable Template = new Variable(); + Variable Goal = new Variable(); + Variable Bag = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"setof", Template, Goal, Bag), B))) + { + foreach (bool l3 in compileBagof(Atom.a(@"resultSet"), Template, Goal, Bag, B, State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ATermCode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"call", A), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.getIterator"), new ListPair(ATermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode), Atom.NIL))) + { + foreach (bool l4 in compileTerm(A, State, ATermCode)) + { + foreach (bool l5 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ATermCode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"asserta", A), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"call", Atom.a(@"YP.asserta"), new ListPair(ATermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode))) + { + foreach (bool l4 in compileTerm(A, State, ATermCode)) + { + foreach (bool l5 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ATermCode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"assertz", A), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"call", Atom.a(@"YP.assertz"), new ListPair(ATermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode))) + { + foreach (bool l4 in compileTerm(A, State, ATermCode)) + { + foreach (bool l5 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"assert", A), B))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor1(@"assertz", A), B), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + Variable Goal = new Variable(); + Variable Catcher = new Variable(); + Variable Handler = new Variable(); + Variable B = new Variable(); + Variable CatchGoal = new Variable(); + Variable GoalTermCode = new Variable(); + Variable BCode = new Variable(); + Variable CatcherTermCode = new Variable(); + Variable HandlerAndBCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"catch", Goal, Catcher, Handler), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor3(@"declare", Atom.a(@"YP.Catch"), CatchGoal, new Functor2(@"new", Atom.a(@"YP.Catch"), new ListPair(new Functor2(@"call", Atom.a(@"YP.getIterator"), new ListPair(GoalTermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), Atom.NIL))), new ListPair(new Functor2(@"foreach", new Functor1(@"var", CatchGoal), BCode), new ListPair(new Functor2(@"foreach", new Functor3(@"callMember", new Functor1(@"var", CatchGoal), Atom.a(@"unifyExceptionOrThrow"), new ListPair(CatcherTermCode, Atom.NIL)), HandlerAndBCode), Atom.NIL))))) + { + foreach (bool l4 in CompilerState.gensym(State, Atom.a(@"catchGoal"), CatchGoal)) + { + foreach (bool l5 in compileTerm(Goal, State, GoalTermCode)) + { + foreach (bool l6 in compileTerm(Catcher, State, CatcherTermCode)) + { + foreach (bool l7 in compileRuleBody(B, State, BCode)) + { + foreach (bool l8 in compileRuleBody(new Functor2(@",", Handler, B), State, HandlerAndBCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ACode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"foreach", ACode, BCode), Atom.NIL))) + { + foreach (bool l4 in compileFunctorCall(A, State, ACode)) + { + foreach (bool l5 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@";", A, B))) + { + if (YP.var(A)) + { + foreach (bool l4 in compileRuleBody(new Functor2(@";", new Functor1(@"call", A), B), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable T = new Variable(); + Variable B = new Variable(); + Variable CutIfLabel = new Variable(); + Variable Code = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@";", new Functor2(@"->", A, T), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"breakableBlock", CutIfLabel, Code), Atom.NIL))) + { + foreach (bool l4 in CompilerState.gensym(State, Atom.a(@"cutIf"), CutIfLabel)) + { + foreach (bool l5 in compileRuleBody(new Functor2(@";", new Functor2(@",", A, new Functor2(@",", new Functor1(@"$CUTIF", CutIfLabel), T)), B), State, Code)) + { + yield return true; + yield break; + } + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ACode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@";", A, B))) + { + foreach (bool l3 in compileRuleBody(A, State, ACode)) + { + foreach (bool l4 in compileRuleBody(B, State, BCode)) + { + foreach (bool l5 in append(ACode, BCode, PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + } + { + object A = arg1; + object State = arg2; + object PseudoCode = arg3; + foreach (bool l2 in compileRuleBody(new Functor2(@",", A, Atom.a(@"true")), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + + public static IEnumerable compileBagof(object ResultMethod, object Template, object Goal, object Bag, object B, object State, object PseudoCode) + { + { + Variable TemplateCode = new Variable(); + Variable GoalTermCode = new Variable(); + Variable UnqualifiedGoal = new Variable(); + Variable BagofAnswers = new Variable(); + Variable GoalAndAddCode = new Variable(); + Variable BagCode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in compileTerm(Template, State, TemplateCode)) + { + foreach (bool l3 in compileTerm(Goal, State, GoalTermCode)) + { + foreach (bool l4 in unqualifiedGoal(Goal, UnqualifiedGoal)) + { + foreach (bool l5 in CompilerState.gensym(State, Atom.a(@"bagofAnswers"), BagofAnswers)) + { + foreach (bool l6 in compileRuleBody(new Functor2(@",", UnqualifiedGoal, new Functor2(@",", new Functor1(@"$DET_NONE_OUT", new Functor3(@"callMember", new Functor1(@"var", BagofAnswers), Atom.a(@"add"), Atom.NIL)), Atom.a(@"fail"))), State, GoalAndAddCode)) + { + foreach (bool l7 in compileTerm(Bag, State, BagCode)) + { + foreach (bool l8 in compileRuleBody(B, State, BCode)) + { + foreach (bool l9 in append(new ListPair(new Functor3(@"declare", Atom.a(@"BagofAnswers"), BagofAnswers, new Functor2(@"new", Atom.a(@"BagofAnswers"), new ListPair(TemplateCode, new ListPair(GoalTermCode, Atom.NIL)))), GoalAndAddCode), new ListPair(new Functor2(@"foreach", new Functor3(@"callMember", new Functor1(@"var", BagofAnswers), ResultMethod, new ListPair(BagCode, Atom.NIL)), BCode), Atom.NIL), PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + } + } + + public static IEnumerable unqualifiedGoal(object arg1, object arg2) + { + { + object Goal = arg1; + foreach (bool l2 in YP.unify(arg2, new Functor1(@"call", Goal))) + { + if (YP.var(Goal)) + { + yield return true; + yield break; + } + } + } + { + object UnqualifiedGoal = arg2; + Variable x1 = new Variable(); + Variable Goal = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"^", x1, Goal))) + { + foreach (bool l3 in unqualifiedGoal(Goal, UnqualifiedGoal)) + { + yield return true; + yield break; + } + } + } + { + Variable UnqualifiedGoal = new Variable(); + foreach (bool l2 in YP.unify(arg1, UnqualifiedGoal)) + { + foreach (bool l3 in YP.unify(arg2, UnqualifiedGoal)) + { + yield return true; + yield break; + } + } + } + } + + public static IEnumerable binaryExpressionConditional(object arg1, object arg2) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"=:="))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.equal"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"=\="))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.notEqual"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@">"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.greaterThan"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"<"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.lessThan"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@">="))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.greaterThanOrEqual"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"=<"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.lessThanOrEqual"))) + { + yield return true; + yield break; + } + } + } + } + + public static IEnumerable compileFunctorCall(object Functor_1, object State, object PseudoCode) + { + { + Variable FunctorName = new Variable(); + Variable FunctorArgs = new Variable(); + Variable x6 = new Variable(); + Variable Arity = new Variable(); + Variable CompiledArgs = new Variable(); + Variable FunctionName = new Variable(); + foreach (bool l2 in YP.univ(Functor_1, new ListPair(FunctorName, FunctorArgs))) + { + foreach (bool l3 in YP.functor(Functor_1, x6, Arity)) + { + foreach (bool l4 in maplist_compileTerm(FunctorArgs, State, CompiledArgs)) + { + foreach (bool l5 in functorCallFunctionName(State, FunctorName, Arity, FunctionName)) + { + if (YP.termEqual(FunctionName, Atom.NIL)) + { + foreach (bool l7 in YP.unify(PseudoCode, new Functor2(@"call", Atom.a(@"YP.matchDynamic"), new ListPair(new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", FunctorName), Atom.NIL)), new ListPair(new Functor1(@"objectArray", CompiledArgs), Atom.NIL))))) + { + yield return true; + yield break; + } + goto cutIf1; + } + foreach (bool l6 in YP.unify(PseudoCode, new Functor2(@"call", FunctionName, CompiledArgs))) + { + yield return true; + yield break; + } + cutIf1: + { } + } + } + } + } + } + } + + public static IEnumerable functorCallFunctionName(object arg1, object arg2, object arg3, object arg4) + { + { + object x1 = arg1; + object Name = arg2; + object Arity = arg3; + object FunctionName = arg4; + foreach (bool l2 in functorCallYPFunctionName(Name, Arity, FunctionName)) + { + yield return true; + yield break; + } + } + { + object State = arg1; + object Arity = arg3; + Variable Name = new Variable(); + foreach (bool l2 in YP.unify(arg2, Name)) + { + foreach (bool l3 in YP.unify(arg4, Name)) + { + if (CompilerState.nameArityHasModule(State, Name, Arity, Atom.a(@""))) + { + yield return true; + yield break; + } + } + } + } + { + object _State = arg1; + object _Arity = arg3; + Variable Name = new Variable(); + foreach (bool l2 in YP.unify(arg2, Name)) + { + foreach (bool l3 in YP.unify(arg4, Name)) + { + foreach (bool l4 in Atom.module(Name, Atom.a(@""))) + { + yield return true; + yield break; + } + } + } + } + { + object _State = arg1; + object Name = arg2; + object Arity = arg3; + foreach (bool l2 in YP.unify(arg4, Atom.NIL)) + { + foreach (bool l3 in Atom.module(Name, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + object _State = arg1; + object Name = arg2; + object Arity = arg3; + object x4 = arg4; + Variable Module = new Variable(); + Variable Message = new Variable(); + foreach (bool l2 in Atom.module(Name, Module)) + { + foreach (bool l3 in YP.atom_concat(Atom.a(@"Not supporting calls to external module: "), Module, Message)) + { + YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"callable"), new Functor2(@"/", Name, Arity)), Message)); + yield return true; + yield break; + } + } + } + { + object _State = arg1; + object Name = arg2; + object _Arity = arg3; + object x4 = arg4; + YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"callable"), Name), Atom.a(@"Term is not callable"))); + yield return true; + yield break; + } + } + + public static IEnumerable functorCallYPFunctionName(object arg1, object arg2, object arg3) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"="))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.unify"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"=.."))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.univ"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"var"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.var"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"nonvar"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.nonvar"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"arg"))) + { + foreach (bool l3 in YP.unify(arg2, 3)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.arg"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"functor"))) + { + foreach (bool l3 in YP.unify(arg2, 3)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.functor"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"repeat"))) + { + foreach (bool l3 in YP.unify(arg2, 0)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.repeat"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"get_code"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.get_code"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"current_op"))) + { + foreach (bool l3 in YP.unify(arg2, 3)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.current_op"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"atom_length"))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atom_length"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"atom_concat"))) + { + foreach (bool l3 in YP.unify(arg2, 3)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atom_concat"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"sub_atom"))) + { + foreach (bool l3 in YP.unify(arg2, 5)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.sub_atom"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"atom_codes"))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atom_codes"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"number_codes"))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.number_codes"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"copy_term"))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.copy_term"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"sort"))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.sort"))) + { + yield return true; + yield break; + } + } + } + } + { + // Manually included : script_event for callback to LSL/C# + + //object x1 = arg1; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"script_event"))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.script_event"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"nl"))) + { + foreach (bool l3 in YP.unify(arg2, 0)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.nl"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"write"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.write"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"put_code"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.put_code"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"atom"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atom"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"integer"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.integer"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"float"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.isFloat"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"number"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.number"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"atomic"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atomic"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"compound"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.compound"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"=="))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termEqual"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"\=="))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termNotEqual"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"@<"))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termLessThan"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"@=<"))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termLessThanOrEqual"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"@>"))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termGreaterThan"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"@>="))) + { + foreach (bool l3 in YP.unify(arg2, 2)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termGreaterThanOrEqual"))) + { + yield return true; + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"throw"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.throwException"))) + { + yield return true; + yield break; + } + } + } + } + } + + public static IEnumerable compileTerm(object arg1, object arg2, object arg3) + { + { + object Term = arg1; + object State = arg2; + Variable VariableName = new Variable(); + foreach (bool l2 in YP.unify(arg3, new Functor1(@"var", VariableName))) + { + if (YP.var(Term)) + { + foreach (bool l4 in CompilerState.getVariableName(State, Term, VariableName)) + { + yield return true; + yield break; + } + } + } + } + { + object _State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg3, new Functor1(@"var", Atom.a(@"Atom.NIL")))) + { + yield return true; + yield break; + } + } + } + { + object Term = arg1; + object State = arg2; + object Code = arg3; + Variable ModuleCode = new Variable(); + if (YP.atom(Term)) + { + foreach (bool l3 in compileAtomModule(Term, 0, State, ModuleCode)) + { + foreach (bool l4 in YP.unify(Code, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Term), new ListPair(ModuleCode, Atom.NIL))))) + { + yield return true; + yield break; + } + goto cutIf1; + } + foreach (bool l3 in YP.unify(Code, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Term), Atom.NIL)))) + { + yield return true; + yield break; + } + cutIf1: + { } + } + } + { + object State = arg2; + Variable First = new Variable(); + Variable Rest = new Variable(); + Variable Arg1 = new Variable(); + Variable Arg2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) + { + foreach (bool l3 in YP.unify(arg3, new Functor2(@"new", Atom.a(@"ListPair"), new ListPair(Arg1, new ListPair(Arg2, Atom.NIL))))) + { + foreach (bool l4 in compileTerm(First, State, Arg1)) + { + foreach (bool l5 in compileTerm(Rest, State, Arg2)) + { + yield return true; + yield break; + } + } + } + } + } + { + object Term = arg1; + object State = arg2; + object Result = arg3; + Variable Name = new Variable(); + Variable TermArgs = new Variable(); + Variable x6 = new Variable(); + Variable Arity = new Variable(); + Variable ModuleCode = new Variable(); + Variable NameCode = new Variable(); + Variable X1 = new Variable(); + Variable Arg1 = new Variable(); + Variable X2 = new Variable(); + Variable Arg2 = new Variable(); + Variable X3 = new Variable(); + Variable Arg3 = new Variable(); + Variable Args = new Variable(); + foreach (bool l2 in YP.univ(Term, new ListPair(Name, TermArgs))) + { + if (YP.termEqual(TermArgs, Atom.NIL)) + { + foreach (bool l4 in YP.unify(Result, new Functor1(@"object", Name))) + { + yield return true; + yield break; + } + goto cutIf2; + } + foreach (bool l3 in YP.functor(Term, x6, Arity)) + { + foreach (bool l4 in compileAtomModule(Name, Arity, State, ModuleCode)) + { + foreach (bool l5 in YP.unify(NameCode, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Name), new ListPair(ModuleCode, Atom.NIL))))) + { + foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL))) + { + foreach (bool l7 in compileTerm(X1, State, Arg1)) + { + foreach (bool l8 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor1"), new ListPair(NameCode, new ListPair(Arg1, Atom.NIL))))) + { + yield return true; + yield break; + } + } + goto cutIf4; + } + foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL)))) + { + foreach (bool l7 in compileTerm(X1, State, Arg1)) + { + foreach (bool l8 in compileTerm(X2, State, Arg2)) + { + foreach (bool l9 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor2"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL)))))) + { + yield return true; + yield break; + } + } + } + goto cutIf5; + } + foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, new ListPair(X3, Atom.NIL))))) + { + foreach (bool l7 in compileTerm(X1, State, Arg1)) + { + foreach (bool l8 in compileTerm(X2, State, Arg2)) + { + foreach (bool l9 in compileTerm(X3, State, Arg3)) + { + foreach (bool l10 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor3"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, new ListPair(Arg3, Atom.NIL))))))) + { + yield return true; + yield break; + } + } + } + } + } + foreach (bool l6 in maplist_compileTerm(TermArgs, State, Args)) + { + foreach (bool l7 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor"), new ListPair(NameCode, new ListPair(new Functor1(@"objectArray", Args), Atom.NIL))))) + { + yield return true; + yield break; + } + } + cutIf5: + cutIf4: + { } + } + goto cutIf3; + } + foreach (bool l4 in YP.unify(NameCode, new Functor1(@"object", Name))) + { + foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL))) + { + foreach (bool l6 in compileTerm(X1, State, Arg1)) + { + foreach (bool l7 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor1"), new ListPair(NameCode, new ListPair(Arg1, Atom.NIL))))) + { + yield return true; + yield break; + } + } + goto cutIf6; + } + foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL)))) + { + foreach (bool l6 in compileTerm(X1, State, Arg1)) + { + foreach (bool l7 in compileTerm(X2, State, Arg2)) + { + foreach (bool l8 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor2"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL)))))) + { + yield return true; + yield break; + } + } + } + goto cutIf7; + } + foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, new ListPair(X3, Atom.NIL))))) + { + foreach (bool l6 in compileTerm(X1, State, Arg1)) + { + foreach (bool l7 in compileTerm(X2, State, Arg2)) + { + foreach (bool l8 in compileTerm(X3, State, Arg3)) + { + foreach (bool l9 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor3"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, new ListPair(Arg3, Atom.NIL))))))) + { + yield return true; + yield break; + } + } + } + } + } + foreach (bool l5 in maplist_compileTerm(TermArgs, State, Args)) + { + foreach (bool l6 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor"), new ListPair(NameCode, new ListPair(new Functor1(@"objectArray", Args), Atom.NIL))))) + { + yield return true; + yield break; + } + } + cutIf7: + cutIf6: + { } + } + cutIf3: + { } + } + cutIf2: + { } + } + } + } + + public static IEnumerable compileAtomModule(object Name, object Arity, object State, object ModuleCode) + { + { + if (CompilerState.nameArityHasModule(State, Name, Arity, Atom.a(@""))) + { + foreach (bool l3 in YP.unify(ModuleCode, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Atom.a(@"")), Atom.NIL)))) + { + yield return true; + yield break; + } + } + } + } + + public static IEnumerable maplist_compileTerm(object arg1, object arg2, object arg3) + { + { + object _State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + Variable First = new Variable(); + Variable Rest = new Variable(); + Variable FirstResult = new Variable(); + Variable RestResults = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(FirstResult, RestResults))) + { + foreach (bool l4 in compileTerm(First, State, FirstResult)) + { + foreach (bool l5 in maplist_compileTerm(Rest, State, RestResults)) + { + yield return true; + yield break; + } + } + } + } + } + } + + public static IEnumerable compileExpression(object Term, object State, object Result) + { + { + Variable Name = new Variable(); + Variable TermArgs = new Variable(); + Variable X1 = new Variable(); + Variable FunctionName = new Variable(); + Variable Arg1 = new Variable(); + Variable x9 = new Variable(); + Variable X2 = new Variable(); + Variable Arg2 = new Variable(); + Variable x12 = new Variable(); + Variable Arity = new Variable(); + if (YP.nonvar(Term)) + { + foreach (bool l3 in YP.univ(Term, new ListPair(Name, TermArgs))) + { + if (YP.atom(Name)) + { + foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL))) + { + foreach (bool l6 in unaryFunction(Name, FunctionName)) + { + foreach (bool l7 in compileExpression(X1, State, Arg1)) + { + foreach (bool l8 in YP.unify(Result, new Functor2(@"call", FunctionName, new ListPair(Arg1, Atom.NIL)))) + { + yield return true; + yield break; + } + } + goto cutIf1; + } + } + foreach (bool l5 in YP.unify(Term, new ListPair(x9, Atom.NIL))) + { + foreach (bool l6 in compileTerm(Term, State, Result)) + { + yield return true; + yield break; + } + goto cutIf2; + } + foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL)))) + { + foreach (bool l6 in binaryFunction(Name, FunctionName)) + { + foreach (bool l7 in compileExpression(X1, State, Arg1)) + { + foreach (bool l8 in compileExpression(X2, State, Arg2)) + { + foreach (bool l9 in YP.unify(Result, new Functor2(@"call", FunctionName, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL))))) + { + yield return true; + yield break; + } + } + } + goto cutIf3; + } + } + foreach (bool l5 in YP.functor(Term, x12, Arity)) + { + YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"evaluable"), new Functor2(@"/", Name, Arity)), Atom.a(@"Not an expression function"))); + yield return false; + } + cutIf3: + cutIf2: + cutIf1: + { } + } + } + } + } + { + foreach (bool l2 in compileTerm(Term, State, Result)) + { + yield return true; + yield break; + } + } + } + + public static IEnumerable unaryFunction(object arg1, object arg2) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"-"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.negate"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"abs"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.abs"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"sign"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.sign"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"floor"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.floor"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"truncate"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.truncate"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"round"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.round"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"floor"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.ceiling"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"sin"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.sin"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"cos"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.cos"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"atan"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.atan"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"exp"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.exp"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"log"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.log"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"sqrt"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.sqrt"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"\"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseComplement"))) + { + yield return true; + yield break; + } + } + } + } + + public static IEnumerable binaryFunction(object arg1, object arg2) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"+"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.add"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"-"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.subtract"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"*"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.multiply"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"/"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.divide"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"//"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.intDivide"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"mod"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.mod"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"**"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.pow"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@">>"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseShiftRight"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"<<"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseShiftLeft"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"/\"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseAnd"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"\/"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseOr"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"min"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.min"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"max"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.max"))) + { + yield return true; + yield break; + } + } + } + } + + public static void convertFunctionCSharp(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"getDeclaringClass"))) + { + YP.write(Atom.a(@"public class YPInnerClass {}")); + YP.nl(); + YP.write(Atom.a(@"public static System.Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; }")); + YP.nl(); + YP.nl(); + return; + } + } + { + Variable ReturnType = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable Body = new Variable(); + Variable Level = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor(@"function", new object[] { ReturnType, Name, ArgList, Body }))) + { + YP.write(Atom.a(@"public static ")); + YP.write(ReturnType); + YP.write(Atom.a(@" ")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@") {")); + YP.nl(); + foreach (bool l3 in YP.unify(Level, 1)) + { + convertStatementListCSharp(Body, Level); + YP.write(Atom.a(@"}")); + YP.nl(); + YP.nl(); + return; + } + } + } + } + + public static IEnumerable convertStatementListCSharp(object arg1, object x1, object x2) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + + public static void convertStatementListCSharp(object arg1, object Level) + { + { + Variable Name = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NewStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", Name, Body), RestStatements))) + { + foreach (bool l3 in append(Body, new ListPair(new Functor1(@"label", Name), RestStatements), NewStatements)) + { + convertStatementListCSharp(NewStatements, Level); + return; + } + } + } + { + Variable Type = new Variable(); + Variable Name = new Variable(); + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"declare", Type, Name, Expression), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Type); + YP.write(Atom.a(@" ")); + YP.write(Name); + YP.write(Atom.a(@" = ")); + convertExpressionCSharp(Expression); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable Name = new Variable(); + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"assign", Name, Expression), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Name); + YP.write(Atom.a(@" = ")); + convertExpressionCSharp(Expression); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldtrue"), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"yield return true;")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldfalse"), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"yield return false;")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldbreak"), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"yield break;")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"return"), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"return;")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returntrue"), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"return true;")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returnfalse"), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"return false;")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable Name = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"label", Name), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Name); + YP.write(Atom.a(@":")); + YP.nl(); + if (YP.termEqual(RestStatements, Atom.NIL)) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"{}")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + goto cutIf1; + } + convertStatementListCSharp(RestStatements, Level); + return; + cutIf1: + { } + } + } + { + Variable Name = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"breakBlock", Name), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"goto ")); + YP.write(Name); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"call", Name, ArgList), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@");")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable Obj = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Obj); + YP.write(Atom.a(@".")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@");")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"{")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListCSharp(Body, NextLevel); + convertIndentationCSharp(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + } + { + Variable Expression = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", Expression, Body), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"if (")); + convertExpressionCSharp(Expression); + YP.write(Atom.a(@") {")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListCSharp(Body, NextLevel); + convertIndentationCSharp(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + } + { + Variable Expression = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", Expression, Body), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"foreach (bool l")); + YP.write(Level); + YP.write(Atom.a(@" in ")); + convertExpressionCSharp(Expression); + YP.write(Atom.a(@") {")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListCSharp(Body, NextLevel); + convertIndentationCSharp(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + } + { + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"throw", Expression), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"throw ")); + convertExpressionCSharp(Expression); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + } + + public static void convertIndentationCSharp(object Level) + { + { + Variable N = new Variable(); + foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2))) + { + repeatWrite(Atom.a(@" "), N); + return; + } + } + } + + public static void convertArgListCSharp(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + Variable Head = new Variable(); + Variable Tail = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail))) + { + convertExpressionCSharp(Head); + if (YP.termNotEqual(Tail, Atom.NIL)) + { + YP.write(Atom.a(@", ")); + convertArgListCSharp(Tail); + return; + goto cutIf1; + } + convertArgListCSharp(Tail); + return; + cutIf1: + { } + } + } + } + + public static void convertExpressionCSharp(object arg1) + { + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"arg", X))) + { + YP.write(Atom.a(@"object ")); + YP.write(X); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"call", Name, ArgList))) + { + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Obj = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList))) + { + YP.write(Obj); + YP.write(Atom.a(@".")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"new", Name, ArgList))) + { + YP.write(Atom.a(@"new ")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Name = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"var", Name))) + { + YP.write(Name); + return; + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"null"))) + { + YP.write(Atom.a(@"null")); + return; + } + } + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"not", X))) + { + YP.write(Atom.a(@"!(")); + convertExpressionCSharp(X); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable X = new Variable(); + Variable Y = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"and", X, Y))) + { + YP.write(Atom.a(@"(")); + convertExpressionCSharp(X); + YP.write(Atom.a(@") && (")); + convertExpressionCSharp(Y); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"objectArray", ArgList))) + { + YP.write(Atom.a(@"new object[] {")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@"}")); + return; + } + } + { + Variable X = new Variable(); + Variable Codes = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) + { + if (YP.atom(X)) + { + YP.write(Atom.a(@"@""")); + foreach (bool l4 in YP.atom_codes(X, Codes)) + { + convertStringCodesCSharp(Codes); + YP.write(Atom.a(@"""")); + return; + } + } + } + } + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) + { + YP.write(X); + return; + } + } + } + + public static void convertStringCodesCSharp(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + Variable Code = new Variable(); + Variable RestCodes = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes))) + { + if (YP.termEqual(Code, 34)) + { + YP.put_code(34); + YP.put_code(Code); + convertStringCodesCSharp(RestCodes); + return; + goto cutIf1; + } + YP.put_code(Code); + convertStringCodesCSharp(RestCodes); + return; + cutIf1: + { } + } + } + } + + public static void convertFunctionJavascript(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"getDeclaringClass"))) + { + YP.write(Atom.a(@"function getDeclaringClass() { return null; }")); + YP.nl(); + return; + } + } + { + Variable x1 = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable Body = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor(@"function", new object[] { x1, Name, ArgList, Body }))) + { + YP.write(Atom.a(@"function ")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@") {")); + YP.nl(); + convertStatementListJavascript(Body, 1); + YP.write(Atom.a(@"}")); + YP.nl(); + YP.nl(); + return; + } + } + } + + public static void convertStatementListJavascript(object arg1, object arg2) + { + { + object x1 = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + object Level = arg2; + Variable Name = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", Name, Body), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Name); + YP.write(Atom.a(@":")); + YP.nl(); + convertIndentationJavascript(Level); + YP.write(Atom.a(@"{")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListJavascript(Body, NextLevel); + convertIndentationJavascript(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + } + { + object Level = arg2; + Variable _Type = new Variable(); + Variable Name = new Variable(); + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"declare", _Type, Name, Expression), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"var ")); + YP.write(Name); + YP.write(Atom.a(@" = ")); + convertExpressionJavascript(Expression); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable Name = new Variable(); + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"assign", Name, Expression), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Name); + YP.write(Atom.a(@" = ")); + convertExpressionJavascript(Expression); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldtrue"), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"yield true;")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldfalse"), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"yield false;")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldbreak"), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"return;")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"return"), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"return;")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returntrue"), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"return true;")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returnfalse"), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"return false;")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable Name = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"breakBlock", Name), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"break ")); + YP.write(Name); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"call", Name, ArgList), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@");")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable Obj = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Obj); + YP.write(Atom.a(@".")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@");")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"{")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListJavascript(Body, NextLevel); + convertIndentationJavascript(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + } + { + object Level = arg2; + Variable Expression = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", Expression, Body), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"if (")); + convertExpressionJavascript(Expression); + YP.write(Atom.a(@") {")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListJavascript(Body, NextLevel); + convertIndentationJavascript(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + } + { + object Level = arg2; + Variable Expression = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", Expression, Body), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"for each (var l")); + YP.write(Level); + YP.write(Atom.a(@" in ")); + convertExpressionJavascript(Expression); + YP.write(Atom.a(@") {")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListJavascript(Body, NextLevel); + convertIndentationJavascript(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + } + { + object Level = arg2; + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"throw", Expression), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"throw ")); + convertExpressionJavascript(Expression); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + } + + public static void convertIndentationJavascript(object Level) + { + { + Variable N = new Variable(); + foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2))) + { + repeatWrite(Atom.a(@" "), N); + return; + } + } + } + + public static void convertArgListJavascript(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + Variable Head = new Variable(); + Variable Tail = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail))) + { + convertExpressionJavascript(Head); + if (YP.termNotEqual(Tail, Atom.NIL)) + { + YP.write(Atom.a(@", ")); + convertArgListJavascript(Tail); + return; + goto cutIf1; + } + convertArgListJavascript(Tail); + return; + cutIf1: + { } + } + } + } + + public static void convertExpressionJavascript(object arg1) + { + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"arg", X))) + { + YP.write(X); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"call", Name, ArgList))) + { + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Obj = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList))) + { + YP.write(Obj); + YP.write(Atom.a(@".")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"new", Name, ArgList))) + { + YP.write(Atom.a(@"new ")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Name = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"var", Name))) + { + YP.write(Name); + return; + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"null"))) + { + YP.write(Atom.a(@"null")); + return; + } + } + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"not", X))) + { + YP.write(Atom.a(@"!(")); + convertExpressionJavascript(X); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable X = new Variable(); + Variable Y = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"and", X, Y))) + { + YP.write(Atom.a(@"(")); + convertExpressionJavascript(X); + YP.write(Atom.a(@") && (")); + convertExpressionJavascript(Y); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"objectArray", ArgList))) + { + YP.write(Atom.a(@"[")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@"]")); + return; + } + } + { + Variable X = new Variable(); + Variable Codes = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) + { + if (YP.atom(X)) + { + YP.write(Atom.a(@"""")); + foreach (bool l4 in YP.atom_codes(X, Codes)) + { + convertStringCodesJavascript(Codes); + YP.write(Atom.a(@"""")); + return; + } + } + } + } + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) + { + YP.write(X); + return; + } + } + } + + public static void convertStringCodesJavascript(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + Variable Code = new Variable(); + Variable RestCodes = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes))) + { + if (YP.termEqual(Code, 34)) + { + YP.put_code(92); + YP.put_code(Code); + convertStringCodesJavascript(RestCodes); + return; + goto cutIf1; + } + if (YP.termEqual(Code, 92)) + { + YP.put_code(92); + YP.put_code(Code); + convertStringCodesJavascript(RestCodes); + return; + goto cutIf1; + } + YP.put_code(Code); + convertStringCodesJavascript(RestCodes); + return; + cutIf1: + { } + } + } + } + + public static void convertFunctionPython(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"getDeclaringClass"))) + { + YP.write(Atom.a(@"def getDeclaringClass():")); + YP.nl(); + YP.write(Atom.a(@" return None")); + YP.nl(); + YP.nl(); + return; + } + } + { + Variable x1 = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable Body = new Variable(); + Variable Level = new Variable(); + Variable HasBreakableBlock = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor(@"function", new object[] { x1, Name, ArgList, Body }))) + { + YP.write(Atom.a(@"def ")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListPython(ArgList); + YP.write(Atom.a(@"):")); + YP.nl(); + foreach (bool l3 in YP.unify(Level, 1)) + { + if (hasBreakableBlockPython(Body)) + { + foreach (bool l5 in YP.unify(HasBreakableBlock, 1)) + { + if (YP.termEqual(HasBreakableBlock, 1)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"doBreak = False")); + YP.nl(); + foreach (bool l7 in convertStatementListPython(Body, Level, HasBreakableBlock)) + { + YP.nl(); + return; + } + goto cutIf2; + } + foreach (bool l6 in convertStatementListPython(Body, Level, HasBreakableBlock)) + { + YP.nl(); + return; + } + cutIf2: + { } + } + goto cutIf1; + } + foreach (bool l4 in YP.unify(HasBreakableBlock, 0)) + { + if (YP.termEqual(HasBreakableBlock, 1)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"doBreak = False")); + YP.nl(); + foreach (bool l6 in convertStatementListPython(Body, Level, HasBreakableBlock)) + { + YP.nl(); + return; + } + goto cutIf3; + } + foreach (bool l5 in convertStatementListPython(Body, Level, HasBreakableBlock)) + { + YP.nl(); + return; + } + cutIf3: + { } + } + cutIf1: + { } + } + } + } + } + + public static bool hasBreakableBlockPython(object arg1) + { + { + Variable _Name = new Variable(); + Variable _Body = new Variable(); + Variable _RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", _Name, _Body), _RestStatements))) + { + return true; + } + } + { + Variable Body = new Variable(); + Variable _RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), _RestStatements))) + { + if (hasBreakableBlockPython(Body)) + { + return true; + } + } + } + { + Variable _Expression = new Variable(); + Variable Body = new Variable(); + Variable _RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", _Expression, Body), _RestStatements))) + { + if (hasBreakableBlockPython(Body)) + { + return true; + } + } + } + { + Variable _Expression = new Variable(); + Variable Body = new Variable(); + Variable _RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", _Expression, Body), _RestStatements))) + { + if (hasBreakableBlockPython(Body)) + { + return true; + } + } + } + { + Variable x1 = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(x1, RestStatements))) + { + if (hasBreakableBlockPython(RestStatements)) + { + return true; + } + } + } + return false; + } + + public static IEnumerable convertStatementListPython(object arg1, object arg2, object arg3) + { + { + object x1 = arg2; + object x2 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + yield return true; + yield break; + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Name = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", Name, Body), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Name); + YP.write(Atom.a(@" = False")); + YP.nl(); + convertIndentationPython(Level); + YP.write(Atom.a(@"for _ in [1]:")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"if ")); + YP.write(Name); + YP.write(Atom.a(@":")); + YP.nl(); + convertIndentationPython(NextLevel); + YP.write(Atom.a(@"doBreak = False")); + YP.nl(); + convertIndentationPython(Level); + YP.write(Atom.a(@"if doBreak:")); + YP.nl(); + convertIndentationPython(NextLevel); + YP.write(Atom.a(@"break")); + YP.nl(); + foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable _Type = new Variable(); + Variable Name = new Variable(); + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"declare", _Type, Name, Expression), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Name); + YP.write(Atom.a(@" = ")); + convertExpressionPython(Expression); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Name = new Variable(); + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"assign", Name, Expression), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Name); + YP.write(Atom.a(@" = ")); + convertExpressionPython(Expression); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldtrue"), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"yield True")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldfalse"), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"yield False")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldbreak"), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"return")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"return"), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"return")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returntrue"), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"return True")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returnfalse"), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"return False")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Name = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"breakBlock", Name), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Name); + YP.write(Atom.a(@" = True")); + YP.nl(); + convertIndentationPython(Level); + YP.write(Atom.a(@"doBreak = True")); + YP.nl(); + convertIndentationPython(Level); + YP.write(Atom.a(@"break")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"call", Name, ArgList), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListPython(ArgList); + YP.write(Atom.a(@")")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Obj = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Obj); + YP.write(Atom.a(@".")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListPython(ArgList); + YP.write(Atom.a(@")")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), RestStatements))) + { + if (YP.termEqual(HasBreakableBlock, 1)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"for _ in [1]:")); + YP.nl(); + foreach (bool l4 in YP.unify(NextLevel, YP.add(Level, 1))) + { + foreach (bool l5 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) + { + if (YP.termEqual(HasBreakableBlock, 1)) + { + if (YP.greaterThan(Level, 1)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"if doBreak:")); + YP.nl(); + convertIndentationPython(NextLevel); + YP.write(Atom.a(@"break")); + YP.nl(); + foreach (bool l8 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + goto cutIf3; + } + foreach (bool l7 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + cutIf3: + goto cutIf2; + } + foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + cutIf2: + { } + } + } + goto cutIf1; + } + foreach (bool l3 in YP.unify(NextLevel, Level)) + { + foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) + { + if (YP.termEqual(HasBreakableBlock, 1)) + { + if (YP.greaterThan(Level, 1)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"if doBreak:")); + YP.nl(); + convertIndentationPython(NextLevel); + YP.write(Atom.a(@"break")); + YP.nl(); + foreach (bool l7 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + goto cutIf5; + } + foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + cutIf5: + goto cutIf4; + } + foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + cutIf4: + { } + } + } + cutIf1: + { } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Expression = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", Expression, Body), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"if ")); + convertExpressionPython(Expression); + YP.write(Atom.a(@":")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) + { + foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Expression = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", Expression, Body), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"for l")); + YP.write(Level); + YP.write(Atom.a(@" in ")); + convertExpressionPython(Expression); + YP.write(Atom.a(@":")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) + { + if (YP.termEqual(HasBreakableBlock, 1)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"if doBreak:")); + YP.nl(); + convertIndentationPython(NextLevel); + YP.write(Atom.a(@"break")); + YP.nl(); + foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + goto cutIf6; + } + foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + cutIf6: + { } + } + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"throw", Expression), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"raise ")); + convertExpressionPython(Expression); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + } + + public static void convertIndentationPython(object Level) + { + { + Variable N = new Variable(); + foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2))) + { + repeatWrite(Atom.a(@" "), N); + return; + } + } + } + + public static void convertArgListPython(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + Variable Head = new Variable(); + Variable Tail = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail))) + { + convertExpressionPython(Head); + if (YP.termNotEqual(Tail, Atom.NIL)) + { + YP.write(Atom.a(@", ")); + convertArgListPython(Tail); + return; + goto cutIf1; + } + convertArgListPython(Tail); + return; + cutIf1: + { } + } + } + } + + public static void convertExpressionPython(object arg1) + { + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"arg", X))) + { + YP.write(X); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"call", Name, ArgList))) + { + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListPython(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Obj = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList))) + { + YP.write(Obj); + YP.write(Atom.a(@".")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListPython(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"new", Name, ArgList))) + { + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListPython(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Name = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"var", Name))) + { + YP.write(Name); + return; + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"null"))) + { + YP.write(Atom.a(@"None")); + return; + } + } + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"not", X))) + { + YP.write(Atom.a(@"not (")); + convertExpressionPython(X); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable X = new Variable(); + Variable Y = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"and", X, Y))) + { + YP.write(Atom.a(@"(")); + convertExpressionPython(X); + YP.write(Atom.a(@") and (")); + convertExpressionPython(Y); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"objectArray", ArgList))) + { + YP.write(Atom.a(@"[")); + convertArgListPython(ArgList); + YP.write(Atom.a(@"]")); + return; + } + } + { + Variable X = new Variable(); + Variable Codes = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) + { + if (YP.atom(X)) + { + YP.write(Atom.a(@"""")); + foreach (bool l4 in YP.atom_codes(X, Codes)) + { + convertStringCodesPython(Codes); + YP.write(Atom.a(@"""")); + return; + } + } + } + } + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) + { + YP.write(X); + return; + } + } + } + + public static void convertStringCodesPython(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + Variable Code = new Variable(); + Variable RestCodes = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes))) + { + if (YP.termEqual(Code, 34)) + { + YP.put_code(92); + YP.put_code(Code); + convertStringCodesPython(RestCodes); + return; + goto cutIf1; + } + if (YP.termEqual(Code, 92)) + { + YP.put_code(92); + YP.put_code(Code); + convertStringCodesPython(RestCodes); + return; + goto cutIf1; + } + YP.put_code(Code); + convertStringCodesPython(RestCodes); + return; + cutIf1: + { } + } + } + } + + public static IEnumerable member(object X, object arg2) + { + { + Variable x2 = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(X, x2))) + { + yield return false; + } + } + { + Variable x2 = new Variable(); + Variable Rest = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(x2, Rest))) + { + foreach (bool l3 in member(X, Rest)) + { + yield return false; + } + } + } + } + + public static IEnumerable append(object arg1, object arg2, object arg3) + { + { + Variable List = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, List)) + { + foreach (bool l4 in YP.unify(arg3, List)) + { + yield return false; + } + } + } + } + { + object List2 = arg2; + Variable X = new Variable(); + Variable List1 = new Variable(); + Variable List12 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(X, List1))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(X, List12))) + { + foreach (bool l4 in append(List1, List2, List12)) + { + yield return false; + } + } + } + } + } + + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/AssemblyResolver.cs b/OpenSim/Region/ScriptEngine/Shared/AssemblyResolver.cs new file mode 100644 index 0000000..f9b160d --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/AssemblyResolver.cs @@ -0,0 +1,65 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.IO; +using System.Reflection; + +namespace OpenSim.Region.ScriptEngine.Shared +{ + [Serializable] + public class AssemblyResolver + { + public static Assembly OnAssemblyResolve(object sender, + ResolveEventArgs args) + { + if (!(sender is System.AppDomain)) + return null; + + AppDomain myDomain = (AppDomain)sender; + string dirName = myDomain.FriendlyName; + + string[] pathList = new string[] {"bin", "ScriptEngines", + Path.Combine("ScriptEngines", dirName)}; + + string assemblyName = args.Name; + if (assemblyName.IndexOf(",") != -1) + assemblyName = args.Name.Substring(0, args.Name.IndexOf(",")); + + foreach (string s in pathList) + { + string path = Path.Combine(Directory.GetCurrentDirectory(), + Path.Combine(s, assemblyName))+".dll"; + + if (File.Exists(path)) + return Assembly.LoadFrom(path); + } + + return null; + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs b/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs new file mode 100644 index 0000000..2edcee0 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs @@ -0,0 +1,515 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.CodeDom.Compiler; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using Microsoft.CSharp; +using Microsoft.JScript; +using Microsoft.VisualBasic; +using OpenSim.Region.Environment.Interfaces; +using OpenSim.Region.ScriptEngine.Interfaces; + +namespace OpenSim.Region.ScriptEngine.Shared.CodeTools +{ + public class Compiler + { + private static readonly log4net.ILog m_log + = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); + + // * Uses "LSL2Converter" to convert LSL to C# if necessary. + // * Compiles C#-code into an assembly + // * Returns assembly name ready for AppDomain load. + // + // Assembly is compiled using LSL_BaseClass as base. Look at debug C# code file created when LSL script is compiled for full details. + // + + internal enum enumCompileType + { + lsl = 0, + cs = 1, + vb = 2, + js = 3 + } + + /// + /// This contains number of lines WE use for header when compiling script. User will get error in line x-LinesToRemoveOnError when error occurs. + /// + public int LinesToRemoveOnError = 3; + private enumCompileType DefaultCompileLanguage; + private bool WriteScriptSourceToDebugFile; + private bool CompileWithDebugInformation; + private Dictionary AllowedCompilers = new Dictionary(StringComparer.CurrentCultureIgnoreCase); + private Dictionary LanguageMapping = new Dictionary(StringComparer.CurrentCultureIgnoreCase); + + private string FilePrefix; + private string ScriptEnginesPath = "ScriptEngines"; + + private static LSL2CSConverter LSL_Converter = new LSL2CSConverter(); + private static CSharpCodeProvider CScodeProvider = new CSharpCodeProvider(); + private static VBCodeProvider VBcodeProvider = new VBCodeProvider(); + private static JScriptCodeProvider JScodeProvider = new JScriptCodeProvider(); + + private static int instanceID = new Random().Next(0, int.MaxValue); // Unique number to use on our compiled files + private static UInt64 scriptCompileCounter = 0; // And a counter + + public IScriptEngine m_scriptEngine; + public Compiler(IScriptEngine scriptEngine) + { + m_scriptEngine = scriptEngine; + ReadConfig(); + } + public bool in_startup = true; + public void ReadConfig() + { + + // Get some config + WriteScriptSourceToDebugFile = m_scriptEngine.Config.GetBoolean("WriteScriptSourceToDebugFile", true); + CompileWithDebugInformation = m_scriptEngine.Config.GetBoolean("CompileWithDebugInformation", true); + + // Get file prefix from scriptengine name and make it file system safe: + FilePrefix = "CommonCompiler"; + foreach (char c in Path.GetInvalidFileNameChars()) + { + FilePrefix = FilePrefix.Replace(c, '_'); + } + + // First time we start? Delete old files + if (in_startup) + { + in_startup = false; + DeleteOldFiles(); + } + + // Map name and enum type of our supported languages + LanguageMapping.Add(enumCompileType.cs.ToString(), enumCompileType.cs); + LanguageMapping.Add(enumCompileType.vb.ToString(), enumCompileType.vb); + LanguageMapping.Add(enumCompileType.lsl.ToString(), enumCompileType.lsl); + LanguageMapping.Add(enumCompileType.js.ToString(), enumCompileType.js); + + // Allowed compilers + string allowComp = m_scriptEngine.Config.GetString("AllowedCompilers", "lsl,cs,vb,js"); + AllowedCompilers.Clear(); + +#if DEBUG + m_scriptEngine.Log.Debug("[Compiler]: Allowed languages: " + allowComp); +#endif + + + foreach (string strl in allowComp.Split(',')) + { + string strlan = strl.Trim(" \t".ToCharArray()).ToLower(); + if (!LanguageMapping.ContainsKey(strlan)) + { + m_scriptEngine.Log.Error("[Compiler]: Config error. Compiler is unable to recognize language type \"" + strlan + "\" specified in \"AllowedCompilers\"."); + } + else + { +#if DEBUG + //m_scriptEngine.Log.Debug("[Compiler]: Config OK. Compiler recognized language type \"" + strlan + "\" specified in \"AllowedCompilers\"."); +#endif + } + AllowedCompilers.Add(strlan, true); + } + if (AllowedCompilers.Count == 0) + m_scriptEngine.Log.Error("[Compiler]: Config error. Compiler could not recognize any language in \"AllowedCompilers\". Scripts will not be executed!"); + + // Default language + string defaultCompileLanguage = m_scriptEngine.Config.GetString("DefaultCompileLanguage", "lsl").ToLower(); + + // Is this language recognized at all? + if (!LanguageMapping.ContainsKey(defaultCompileLanguage)) + { + m_scriptEngine.Log.Error("[Compiler]: " + + "Config error. Default language \"" + defaultCompileLanguage + "\" specified in \"DefaultCompileLanguage\" is not recognized as a valid language. Changing default to: \"lsl\"."); + defaultCompileLanguage = "lsl"; + } + + // Is this language in allow-list? + if (!AllowedCompilers.ContainsKey(defaultCompileLanguage)) + { + m_scriptEngine.Log.Error("[Compiler]: " + + "Config error. Default language \"" + defaultCompileLanguage + "\"specified in \"DefaultCompileLanguage\" is not in list of \"AllowedCompilers\". Scripts may not be executed!"); + } + else + { +#if DEBUG +// m_scriptEngine.Log.Debug("[Compiler]: " + +// "Config OK. Default language \"" + defaultCompileLanguage + "\" specified in \"DefaultCompileLanguage\" is recognized as a valid language."); +#endif + // LANGUAGE IS IN ALLOW-LIST + DefaultCompileLanguage = LanguageMapping[defaultCompileLanguage]; + } + + // We now have an allow-list, a mapping list, and a default language + + } + + /// + /// Delete old script files + /// + private void DeleteOldFiles() + { + + // CREATE FOLDER IF IT DOESNT EXIST + if (!Directory.Exists(ScriptEnginesPath)) + { + try + { + Directory.CreateDirectory(ScriptEnginesPath); + } + catch (Exception ex) + { + m_scriptEngine.Log.Error("[Compiler]: Exception trying to create ScriptEngine directory \"" + ScriptEnginesPath + "\": " + ex.ToString()); + } + } + + if (!Directory.Exists(Path.Combine(ScriptEnginesPath, + m_scriptEngine.World.RegionInfo.RegionID.ToString()))) + { + try + { + Directory.CreateDirectory(Path.Combine(ScriptEnginesPath, + m_scriptEngine.World.RegionInfo.RegionID.ToString())); + } + catch (Exception ex) + { + m_scriptEngine.Log.Error("[Compiler]: Exception trying to create ScriptEngine directory \"" + Path.Combine(ScriptEnginesPath, + m_scriptEngine.World.RegionInfo.RegionID.ToString())+ "\": " + ex.ToString()); + } + } + + foreach (string file in Directory.GetFiles(Path.Combine(ScriptEnginesPath, + m_scriptEngine.World.RegionInfo.RegionID.ToString()))) + { + //m_scriptEngine.Log.Error("[Compiler]: FILE FOUND: " + file); + + if (file.ToLower().StartsWith(FilePrefix + "_compiled_") || + file.ToLower().StartsWith(FilePrefix + "_source_")) + { + try + { + File.Delete(file); + } + catch (Exception ex) + { + m_scriptEngine.Log.Error("[Compiler]: Exception trying delete old script file \"" + file + "\": " + ex.ToString()); + } + + } + } + + } + + ////private ICodeCompiler icc = codeProvider.CreateCompiler(); + //public string CompileFromFile(string LSOFileName) + //{ + // switch (Path.GetExtension(LSOFileName).ToLower()) + // { + // case ".txt": + // case ".lsl": + // Common.ScriptEngineBase.Shared.SendToDebug("Source code is LSL, converting to CS"); + // return CompileFromLSLText(File.ReadAllText(LSOFileName)); + // case ".cs": + // Common.ScriptEngineBase.Shared.SendToDebug("Source code is CS"); + // return CompileFromCSText(File.ReadAllText(LSOFileName)); + // default: + // throw new Exception("Unknown script type."); + // } + //} + + /// + /// Converts script from LSL to CS and calls CompileFromCSText + /// + /// LSL script + /// Filename to .dll assembly + public string PerformScriptCompile(string Script, string asset) + { + string OutFile = Path.Combine(ScriptEnginesPath, Path.Combine( + m_scriptEngine.World.RegionInfo.RegionID.ToString(), + FilePrefix + "_compiled_" + asset + ".dll")); +// string OutFile = Path.Combine(ScriptEnginesPath, +// FilePrefix + "_compiled_" + asset + ".dll"); + + if (File.Exists(OutFile)) + { + m_scriptEngine.Log.DebugFormat("[Compiler] Returning existing assembly for {0}", asset); + return OutFile; + } + + if (!Directory.Exists(ScriptEnginesPath)) + { + try + { + Directory.CreateDirectory(ScriptEnginesPath); + } + catch (Exception ex) + { + } + } + + if (!Directory.Exists(Path.Combine(ScriptEnginesPath, + m_scriptEngine.World.RegionInfo.RegionID.ToString()))) + { + try + { + Directory.CreateDirectory(ScriptEnginesPath); + } + catch (Exception ex) + { + } + } + + enumCompileType l = DefaultCompileLanguage; + + if (Script.StartsWith("//c#", true, CultureInfo.InvariantCulture)) + l = enumCompileType.cs; + if (Script.StartsWith("//vb", true, CultureInfo.InvariantCulture)) + { + l = enumCompileType.vb; + // We need to remove //vb, it won't compile with that + + Script = Script.Substring(4, Script.Length - 4); + } + if (Script.StartsWith("//lsl", true, CultureInfo.InvariantCulture)) + l = enumCompileType.lsl; + + if (Script.StartsWith("//js", true, CultureInfo.InvariantCulture)) + l = enumCompileType.js; + + if (!AllowedCompilers.ContainsKey(l.ToString())) + { + // Not allowed to compile to this language! + string errtext = String.Empty; + errtext += "The compiler for language \"" + l.ToString() + "\" is not in list of allowed compilers. Script will not be executed!"; + throw new Exception(errtext); + } + + string compileScript = Script; + + if (l == enumCompileType.lsl) + { + // Its LSL, convert it to C# + compileScript = LSL_Converter.Convert(Script); + l = enumCompileType.cs; + } + + // Insert additional assemblies here + + //ADAM: Disabled for the moment until it's working right. + bool enableCommanderLSL = false; + + if (enableCommanderLSL == true && l == enumCompileType.cs) + { + foreach (KeyValuePair com + in m_scriptEngine.World.GetCommanders()) + { + compileScript = com.Value.GenerateRuntimeAPI() + compileScript; + } + } + + // End of insert + + switch (l) + { + case enumCompileType.cs: + compileScript = CreateCSCompilerScript(compileScript); + break; + case enumCompileType.vb: + compileScript = CreateVBCompilerScript(compileScript); + break; + case enumCompileType.js: + compileScript = CreateJSCompilerScript(compileScript); + break; + } + +// m_log.Debug("[ScriptEngine.DotNetEngine]: Preparing to compile the following LSL to C# translated code"); +// m_log.Debug(""); +// m_log.Debug(compileScript); + + return CompileFromDotNetText(compileScript, l, asset); + } + + private static string CreateJSCompilerScript(string compileScript) + { + compileScript = String.Empty + + "import OpenSim.Region.ScriptEngine.Shared; import System.Collections.Generic;\r\n" + + "package SecondLife {\r\n" + + "class Script extends OpenSim.Region.ScriptEngine.Shared.ScriptBase.ScriptBaseClass { \r\n" + + compileScript + + "} }\r\n"; + return compileScript; + } + + private static string CreateCSCompilerScript(string compileScript) + { + compileScript = String.Empty + + "using OpenSim.Region.ScriptEngine.Shared; using System.Collections.Generic;\r\n" + + String.Empty + "namespace SecondLife { " + + String.Empty + "public class Script : OpenSim.Region.ScriptEngine.Shared.ScriptBase.ScriptBaseClass { \r\n" + + @"public Script() { } " + + compileScript + + "} }\r\n"; + return compileScript; + } + + private static string CreateVBCompilerScript(string compileScript) + { + compileScript = String.Empty + + "Imports OpenSim.Region.ScriptEngine.Shared: Imports System.Collections.Generic: " + + String.Empty + "NameSpace SecondLife:" + + String.Empty + "Public Class Script: Inherits OpenSim.Region.ScriptEngine.Shared.ScriptBase.ScriptBaseClass: " + + "\r\nPublic Sub New()\r\nEnd Sub: " + + compileScript + + ":End Class :End Namespace\r\n"; + return compileScript; + } + + /// + /// Compile .NET script to .Net assembly (.dll) + /// + /// CS script + /// Filename to .dll assembly + internal string CompileFromDotNetText(string Script, enumCompileType lang, string asset) + { + string ext = "." + lang.ToString(); + + // Output assembly name + scriptCompileCounter++; + string OutFile = Path.Combine(ScriptEnginesPath, Path.Combine( + m_scriptEngine.World.RegionInfo.RegionID.ToString(), + FilePrefix + "_compiled_" + asset + ".dll")); +#if DEBUG +// m_scriptEngine.Log.Debug("[Compiler]: Starting compile of \"" + OutFile + "\"."); +#endif + try + { + File.Delete(OutFile); + } + catch (Exception e) // NOTLEGIT - Should be just catching FileIOException + { + //m_scriptEngine.Log.Error("[Compiler]: Unable to delete old existring script-file before writing new. Compile aborted: " + e.ToString()); + throw new Exception("Unable to delete old existring script-file before writing new. Compile aborted: " + e.ToString()); + } + //string OutFile = Path.Combine("ScriptEngines", "SecondLife.Script.dll"); + + // DEBUG - write source to disk + if (WriteScriptSourceToDebugFile) + { + string srcFileName = FilePrefix + "_source_" + Path.GetFileNameWithoutExtension(OutFile) + ext; + try + { + File.WriteAllText(Path.Combine(Path.Combine( + ScriptEnginesPath, + m_scriptEngine.World.RegionInfo.RegionID.ToString()), + srcFileName), Script); + } + catch (Exception ex) // NOTLEGIT - Should be just catching FileIOException + { + m_scriptEngine.Log.Error("[Compiler]: Exception while trying to write script source to file \"" + srcFileName + "\": " + ex.ToString()); + } + } + + // Do actual compile + CompilerParameters parameters = new CompilerParameters(); + + parameters.IncludeDebugInformation = true; + + // Add all available assemblies +// foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies()) +// { +// Console.WriteLine("Adding assembly: " + asm.Location); +// parameters.ReferencedAssemblies.Add(asm.Location); +// } + + string rootPath = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory); + string rootPathSE = Path.GetDirectoryName(GetType().Assembly.Location); + //Console.WriteLine("Assembly location: " + rootPath); + parameters.ReferencedAssemblies.Add(Path.Combine(rootPath, "OpenSim.Region.ScriptEngine.Shared.dll")); + parameters.ReferencedAssemblies.Add(Path.Combine(rootPath, "OpenSim.Region.ScriptEngine.Shared.Api.Runtime.dll")); + + parameters.GenerateExecutable = false; + parameters.OutputAssembly = OutFile; + parameters.IncludeDebugInformation = CompileWithDebugInformation; + //parameters.WarningLevel = 1; // Should be 4? + parameters.TreatWarningsAsErrors = false; + +//Console.WriteLine(Script); + CompilerResults results; + switch (lang) + { + case enumCompileType.vb: + results = VBcodeProvider.CompileAssemblyFromSource(parameters, Script); + break; + case enumCompileType.cs: + results = CScodeProvider.CompileAssemblyFromSource(parameters, Script); + break; + case enumCompileType.js: + results = JScodeProvider.CompileAssemblyFromSource(parameters, Script); + break; + default: + throw new Exception("Compiler is not able to recongnize language type \"" + lang.ToString() + "\""); + } + + // Check result + // Go through errors + + // + // WARNINGS AND ERRORS + // + if (results.Errors.Count > 0) + { + string errtext = String.Empty; + foreach (CompilerError CompErr in results.Errors) + { + errtext += "Line number " + (CompErr.Line - LinesToRemoveOnError) + + ", Error Number: " + CompErr.ErrorNumber + + ", '" + CompErr.ErrorText + "'\r\n"; + } + if (!File.Exists(OutFile)) + { + throw new Exception(errtext); + } + } + + // + // NO ERRORS, BUT NO COMPILED FILE + // + if (!File.Exists(OutFile)) + { + string errtext = String.Empty; + errtext += "No compile error. But not able to locate compiled file."; + throw new Exception(errtext); + } + m_scriptEngine.Log.DebugFormat("[Compiler] Compiled new assembly for {0}", asset); + return OutFile; + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/CodeTools/LSL2CSConverter.cs b/OpenSim/Region/ScriptEngine/Shared/CodeTools/LSL2CSConverter.cs new file mode 100644 index 0000000..380686e --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/CodeTools/LSL2CSConverter.cs @@ -0,0 +1,374 @@ +/* +* Copyright (c) Contributors, http://opensimulator.org/ +* See CONTRIBUTORS.TXT for a full list of copyright holders. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* * Neither the name of the OpenSim Project nor the +* names of its contributors may be used to endorse or promote products +* derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS AS IS AND ANY +* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY +* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*/ + +using System; +using System.Collections.Generic; +using System.Text.RegularExpressions; + +namespace OpenSim.Region.ScriptEngine.Shared.CodeTools +{ + public class LSL2CSConverter + { + // Uses regex to convert LSL code to C# code. + + //private Regex rnw = new Regex(@"[a-zA-Z0-9_\-]", RegexOptions.Compiled); + private Dictionary dataTypes = new Dictionary(); + private Dictionary quotes = new Dictionary(); + // c Style + private Regex cstylecomments = new Regex(@"/\*(.|[\r\n])*?\*/", RegexOptions.Compiled | RegexOptions.Multiline); + // c# one liners + private Regex nonCommentFwsl = new Regex("\"[a-zA-Z0-9.,:/\\n ]+//[^\"+]+([\\\\\\\"+]+)?(\\s+)?[\"+](\\s+)?(;)?", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + private Regex conelinecomments = new Regex(@"[^:].?([\/]{2}[^\n]*)|([\n]{1,}[\/]{2}[^\n]*)", RegexOptions.Compiled | RegexOptions.Multiline); + // ([^\"])((?:[a-zA-Z])\.[a-zA-Z].?)([^\"]) + + // value we're looking for: (?:[a-zA-Z])\.[a-zA-Z] + public LSL2CSConverter() + { + // Only the types we need to convert + dataTypes.Add("void", "void"); + dataTypes.Add("integer", "LSL_Types.LSLInteger"); + dataTypes.Add("float", "LSL_Types.LSLFloat"); + dataTypes.Add("string", "LSL_Types.LSLString"); + dataTypes.Add("key", "LSL_Types.LSLString"); + dataTypes.Add("vector", "LSL_Types.Vector3"); + dataTypes.Add("rotation", "LSL_Types.Quaternion"); + dataTypes.Add("list", "LSL_Types.list"); + dataTypes.Add("null", "null"); + } + + public string Convert(string Script) + { + quotes.Clear(); + string Return = String.Empty; + Script = " \r\n" + Script; + + // + // Prepare script for processing + // + + // Clean up linebreaks + Script = Regex.Replace(Script, @"\r\n", "\n"); + Script = Regex.Replace(Script, @"\n", "\r\n"); + + // QUOTE REPLACEMENT + // temporarily replace quotes so we can work our magic on the script without + // always considering if we are inside our outside quotes's + // TODO: Does this work on half-quotes in strings? ;) + string _Script = String.Empty; + string C; + bool in_quote = false; + bool quote_replaced = false; + string quote_replacement_string = "Q_U_O_T_E_REPLACEMENT_"; + string quote = String.Empty; + bool last_was_escape = false; + int quote_replaced_count = 0; + + string removefwnoncomments = nonCommentFwsl.Replace(Script, "\"\";"); + + string removecomments = conelinecomments.Replace(removefwnoncomments, ""); + removecomments = cstylecomments.Replace(removecomments, ""); + string[] localscript = removecomments.Split('"'); + string checkscript = String.Empty; + bool flip = true; + + for (int p = 0; p < localscript.Length; p++) + { + //if (localscript[p].Length >= 1) + //{ + if (!localscript[p].EndsWith(@"\")) + { + flip = !flip; + //System.Console.WriteLine("Flip:" + flip.ToString() + " - " + localscript[p] + " ! " + localscript[p].EndsWith(@"\").ToString()); + } + //} + //else + //{ + // flip = !flip; + // System.Console.WriteLine("Flip:" + flip.ToString() + " - " + localscript[p]); + //} + if (!flip) + checkscript += localscript[p]; + } + + //System.Console.WriteLine("SCRIPT:" + checkscript); + + // checks for alpha.alpha way of referring to objects in C# + // ignores alpha.x alpha.y, alpha.z for refering to vector components + Match SecurityM; + + // BROKEN: this check is very wrong. It block's any url in strings. + SecurityM = Regex.Match(checkscript, @"(?:[a-zA-Z])\.(?:[a-wA-Z]|[a-zA-Z][a-zA-Z])", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + + if (SecurityM.Success) + throw new Exception("CS0103: 'The . symbol cannot be used in LSL except in float values or vector components'. Detected around: " + SecurityM.Captures[0].Value); + + SecurityM = Regex.Match(checkscript, @"typeof\s", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + if (SecurityM.Success) + throw new Exception("CS0103: 'The object.typeof method isn't allowed in LSL'"); + + SecurityM = Regex.Match(checkscript, @"GetType\(", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + if (SecurityM.Success) + throw new Exception("CS0103: 'The object.GetType method isn't allowed in LSL'"); + + for (int p = 0; p < Script.Length; p++) + { + C = Script.Substring(p, 1); + while (true) + { + // found " and last was not \ so this is not an escaped \" + if (C == "\"" && last_was_escape == false) + { + // Toggle inside/outside quote + in_quote = !in_quote; + if (in_quote) + { + quote_replaced_count++; + } + else + { + if (quote == String.Empty) + { + // We didn't replace quote, probably because of empty string? + _Script += quote_replacement_string + + quote_replaced_count.ToString().PadLeft(5, "0".ToCharArray()[0]); + } + // We just left a quote + quotes.Add( + quote_replacement_string + + quote_replaced_count.ToString().PadLeft(5, "0".ToCharArray()[0]), quote); + quote = String.Empty; + } + break; + } + + if (!in_quote) + { + // We are not inside a quote + quote_replaced = false; + } + else + { + // We are inside a quote + if (!quote_replaced) + { + // Replace quote + _Script += quote_replacement_string + + quote_replaced_count.ToString().PadLeft(5, "0".ToCharArray()[0]); + quote_replaced = true; + } + quote += C; + break; + } + _Script += C; + break; + } + last_was_escape = false; + if (C == @"\") + { + last_was_escape = true; + } + } + Script = _Script; + // + // END OF QUOTE REPLACEMENT + // + + // + // PROCESS STATES + // Remove state definitions and add state names to start of each event within state + // + int ilevel = 0; + int lastlevel = 0; + string ret = String.Empty; + string cache = String.Empty; + bool in_state = false; + string current_statename = String.Empty; + for (int p = 0; p < Script.Length; p++) + { + C = Script.Substring(p, 1); + while (true) + { + // inc / dec level + if (C == @"{") + ilevel++; + if (C == @"}") + ilevel--; + if (ilevel < 0) + ilevel = 0; + cache += C; + + // if level == 0, add to return + if (ilevel == 1 && lastlevel == 0) + { + // 0 => 1: Get last + Match m = + //Regex.Match(cache, @"(?![a-zA-Z_]+)\s*([a-zA-Z_]+)[^a-zA-Z_\(\)]*{", + Regex.Match(cache, @"(?![a-zA-Z_]+)\s*(state\s+)?(?[a-zA-Z_][a-zA-Z_0-9]*)[^a-zA-Z_0-9\(\)]*{", + + RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + + in_state = false; + if (m.Success) + { + // Go back to level 0, this is not a state + in_state = true; + current_statename = m.Groups["statename"].Captures[0].Value; + //Console.WriteLine("Current statename: " + current_statename); + cache = + //@"(?(?![a-zA-Z_]+)\s*)" + @"([a-zA-Z_]+)(?[^a-zA-Z_\(\)]*){", + Regex.Replace(cache, + @"(?(?![a-zA-Z_]+)\s*)" + @"(state\s+)?([a-zA-Z_][a-zA-Z_0-9]*)(?[^a-zA-Z_0-9\(\)]*){", + "${s1}${s2}", + RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase); + } + ret += cache; + cache = String.Empty; + } + if (ilevel == 0 && lastlevel == 1) + { + // 1 => 0: Remove last } + if (in_state == true) + { + cache = cache.Remove(cache.Length - 1, 1); + //cache = Regex.Replace(cache, "}$", String.Empty, RegexOptions.Multiline | RegexOptions.Singleline); + + //Replace function names + // void dataserver(key query_id, string data) { + //cache = Regex.Replace(cache, @"([^a-zA-Z_]\s*)((?!if|switch|for)[a-zA-Z_]+\s*\([^\)]*\)[^{]*{)", "$1" + "" + "$2", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + //Console.WriteLine("Replacing using statename: " + current_statename); + cache = + Regex.Replace(cache, + @"^(\s*)((?!(if|switch|for|while)[^a-zA-Z0-9_])[a-zA-Z0-9_]*\s*\([^\)]*\)[^;]*\{)", + @"$1public " + current_statename + "_event_$2", + RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase); + } + + ret += cache; + cache = String.Empty; + in_state = true; + current_statename = String.Empty; + } + + break; + } + lastlevel = ilevel; + } + ret += cache; + cache = String.Empty; + + Script = ret; + ret = String.Empty; + + foreach (string key in dataTypes.Keys) + { + string val; + dataTypes.TryGetValue(key, out val); + + // Replace CAST - (integer) with (int) + Script = + Regex.Replace(Script, @"\(" + key + @"\)", @"(" + val + ")", + RegexOptions.Compiled | RegexOptions.Multiline); + // Replace return types and function variables - integer a() and f(integer a, integer a) + Script = + Regex.Replace(Script, @"(^|;|}|[\(,])(\s*)" + key + @"(\s+)", @"$1$2" + val + "$3", + RegexOptions.Compiled | RegexOptions.Multiline); + Script = + Regex.Replace(Script, @"(^|;|}|[\(,])(\s*)" + key + @"(\s*)[,]", @"$1$2" + val + "$3,", + RegexOptions.Compiled | RegexOptions.Multiline); + } + + // Change jumps into goto's and prefix its label + Script = + Regex.Replace(Script, + @"(\W)jump\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*;", + @"$1goto label_$2;", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + // and prefix labels so the do not clash with C#'s reserved words + Script = + Regex.Replace(Script, + @"@([a-zA-Z_][a-zA-Z_0-9]*)\s*;", + @"label_$1: ;", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + + // Add "void" in front of functions that needs it + Script = + Regex.Replace(Script, + @"^(\s*public\s+)?((?!(if|switch|for)[^a-zA-Z0-9_])[a-zA-Z0-9_]*\s*\([^\)]*\)[^;]*\{)", + @"$1void $2", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + + // Replace and + Script = + Regex.Replace(Script, @"<([^,>;]*,[^,>;]*,[^,>;]*,[^,>;]*)>", @"new LSL_Types.Quaternion($1)", + RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + Script = + Regex.Replace(Script, @"<([^,>;)]*,[^,>;]*,[^,>;]*)>", @"new LSL_Types.Vector3($1)", + RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + + // Replace List []'s + Script = + Regex.Replace(Script, @"\[([^\]]*)\]", @"new LSL_Types.list($1)", + RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + + // Replace (string) to .ToString() // + Script = + Regex.Replace(Script, @"\(string\)\s*([a-zA-Z0-9_.]+(\s*\([^\)]*\))?)", @"$1.ToString()", + RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + Script = + Regex.Replace(Script, @"\((float|int)\)\s*([a-zA-Z0-9_.]+(\s*\([^\)]*\))?)", @"$1.Parse($2)", + RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); + + // Replace "state STATENAME" with "state("statename")" + Script = + Regex.Replace(Script, @"(state)\s+([^;\n\r]+)(;[\r\n\s])", "$1(\"$2\")$3", + RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase); + + // REPLACE BACK QUOTES + foreach (string key in quotes.Keys) + { + string val; + quotes.TryGetValue(key, out val); + Script = Script.Replace(key, "\"" + val + "\""); + } + + //System.Console.WriteLine(Script); + Return = String.Empty;// + + //"using OpenSim.Region.ScriptEngine.Shared; using System.Collections.Generic;"; + + //Return += String.Empty + + // "namespace SecondLife { "; + //Return += String.Empty + + // //"[Serializable] " + + // "public class Script : OpenSim.Region.ScriptEngine.Shared.LSL_BaseClass { "; + //Return += @"public Script() { } "; + Return += Script; + //Return += "} }\r\n"; + + quotes.Clear(); + + return Return; + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/CodeTools/YP2CSConverter.cs b/OpenSim/Region/ScriptEngine/Shared/CodeTools/YP2CSConverter.cs new file mode 100644 index 0000000..54b4861 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/CodeTools/YP2CSConverter.cs @@ -0,0 +1,108 @@ +/* +* Copyright (c) Contributors, http://opensimulator.org/ +* See CONTRIBUTORS.TXT for a full list of copyright holders. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* * Neither the name of the OpenSim Project nor the +* names of its contributors may be used to endorse or promote products +* derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS AS IS AND ANY +* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY +* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*/ + +using System; +using System.IO; +using System.Collections.Generic; +using System.Text; +using System.Text.RegularExpressions; +using OpenSim.Region.ScriptEngine.Shared.YieldProlog; + +namespace OpenSim.Region.ScriptEngine.Shared.CodeTools +{ + public class YP2CSConverter + { + public YP2CSConverter() + { + } + + public string Convert(string Script) + { + string CS_code = GenCode(Script); + return CS_code; + } + + static string GenCode(string myCode) + { + Variable TermList = new Variable(); + Variable FunctionCode = new Variable(); + + string CS_code = ""; + + int cs_pointer = myCode.IndexOf("\n//cs"); + if (cs_pointer > 0) + { + CS_code = myCode.Substring(cs_pointer); // CS code comes after + myCode = myCode.Substring(0, cs_pointer); + } + myCode.Replace("//yp", "%YPCode"); + + StringWriter myCS_SW = new StringWriter(); + StringReader myCode_SR = new StringReader(" yp_nop_header_nop. \n "+myCode + "\n"); + + YP.see(myCode_SR); + YP.tell(myCS_SW); + + //Console.WriteLine("Mycode\n ===================================\n" + myCode+"\n"); + foreach (bool l1 in Parser.parseInput(TermList)) + { + foreach (bool l2 in YPCompiler.makeFunctionPseudoCode(TermList, FunctionCode)) + { + ListPair VFC = new ListPair(FunctionCode, new Variable()); + //Console.WriteLine("-------------------------") + //Console.WriteLine(FunctionCode.ToString()) + //Console.WriteLine("-------------------------") + YPCompiler.convertFunctionCSharp(FunctionCode); + //YPCompiler.convertStringCodesCSharp(VFC); + } + } + YP.seen(); + myCS_SW.Close(); + YP.told(); + StringBuilder bu = myCS_SW.GetStringBuilder(); + string finalcode = "//YPEncoded\n" + bu.ToString(); + // FIX script events (we're in the same script) + // 'YP.script_event(Atom.a(@"sayit"),' ==> 'sayit(' + finalcode = Regex.Replace(finalcode, + @"YP.script_event\(Atom.a\(\@\""(.*?)""\)\,", + @"this.$1(", + RegexOptions.Compiled | RegexOptions.Singleline); + finalcode = Regex.Replace(finalcode, + @" static ", + @" ", + RegexOptions.Compiled | RegexOptions.Singleline); + + finalcode = CS_code+"\n\r"+ finalcode; + finalcode = Regex.Replace(finalcode, + @"PrologCallback", + @"public IEnumerable ", + RegexOptions.Compiled | RegexOptions.Singleline); + return finalcode; + } + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/Helpers.cs b/OpenSim/Region/ScriptEngine/Shared/Helpers.cs new file mode 100644 index 0000000..8e312c5 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/Helpers.cs @@ -0,0 +1,121 @@ +using System; +using System.IO; +using System.Threading; +using System.Collections; +using System.Collections.Generic; +using libsecondlife; +using OpenSim.Framework; +using OpenSim.Region.Environment; +using OpenSim.Region.Environment.Scenes; + +namespace OpenSim.Region.ScriptEngine.Shared +{ + public class DetectParams + { + public DetectParams() + { + Key = LLUUID.Zero; + OffsetPos = new LSL_Types.Vector3(); + LinkNum = 0; + Group = LLUUID.Zero; + Name = String.Empty; + Owner = LLUUID.Zero; + Position = new LSL_Types.Vector3(); + Rotation = new LSL_Types.Quaternion(); + Type = 0; + Velocity = new LSL_Types.Vector3(); + } + + public LLUUID Key; + public LSL_Types.Vector3 OffsetPos; + public int LinkNum; + public LLUUID Group; + public string Name; + public LLUUID Owner; + public LSL_Types.Vector3 Position; + public LSL_Types.Quaternion Rotation; + public int Type; + public LSL_Types.Vector3 Velocity; + + public void Populate(Scene scene) + { + SceneObjectPart part = scene.GetSceneObjectPart(Key); + if (part == null) // Avatar, maybe? + { + ScenePresence presence = scene.GetScenePresence(Key); + if (presence == null) + return; + + Name = presence.Firstname + " " + presence.Lastname; + Owner = Key; + Position = new LSL_Types.Vector3( + presence.AbsolutePosition.X, + presence.AbsolutePosition.X, + presence.AbsolutePosition.Z); + Rotation = new LSL_Types.Quaternion( + presence.Rotation.x, + presence.Rotation.y, + presence.Rotation.z, + presence.Rotation.w); + Velocity = new LSL_Types.Vector3( + presence.Velocity.X, + presence.Velocity.X, + presence.Velocity.Z); + + Type = 0x01; // Avatar + if (presence.Velocity != LLVector3.Zero) + Type |= 0x02; // Active + + Group = presence.ControllingClient.ActiveGroupId; + + return; + } + + part=part.ParentGroup.RootPart; // We detect objects only + + LinkNum = 0; // Not relevant + + Group = part.GroupID; + Name = part.Name; + Owner = part.OwnerID; + if (part.Velocity == LLVector3.Zero) + Type = 0x04; // Passive + else + Type = 0x02; // Passive + + foreach (SceneObjectPart p in part.ParentGroup.Children.Values) + { + if (p.ContainsScripts()) + { + Type |= 0x08; // Scripted + break; + } + } + + Position = new LSL_Types.Vector3(part.AbsolutePosition.X, + part.AbsolutePosition.Y, + part.AbsolutePosition.Z); + + LLQuaternion wr = part.GetWorldRotation(); + Rotation = new LSL_Types.Quaternion(wr.X, wr.Y, wr.Z, wr.W); + + Velocity = new LSL_Types.Vector3(part.Velocity.X, + part.Velocity.Y, + part.Velocity.Z); + } + } + + public class EventParams + { + public EventParams(string eventName, Object[] eventParams, DetectParams[] detectParams) + { + EventName=eventName; + Params=eventParams; + DetectParams=detectParams; + } + + public string EventName; + public Object[] Params; + public DetectParams[] DetectParams; + } +} diff --git a/OpenSim/Region/ScriptEngine/Shared/LSL_Types.cs b/OpenSim/Region/ScriptEngine/Shared/LSL_Types.cs new file mode 100644 index 0000000..6b080a0 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/Shared/LSL_Types.cs @@ -0,0 +1,1519 @@ +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSim Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +using System; +using System.Collections; +using System.Text.RegularExpressions; + +namespace OpenSim.Region.ScriptEngine.Shared +{ + [Serializable] + public partial class LSL_Types + { + // Types are kept is separate .dll to avoid having to add whatever .dll it is in it to script AppDomain + + [Serializable] + public struct Vector3 + { + public double x; + public double y; + public double z; + + #region Constructors + + public Vector3(Vector3 vector) + { + x = (float)vector.x; + y = (float)vector.y; + z = (float)vector.z; + } + + public Vector3(double X, double Y, double Z) + { + x = X; + y = Y; + z = Z; + } + + public Vector3(string str) + { + str = str.Replace('<', ' '); + str = str.Replace('>', ' '); + string[] tmps = str.Split(new Char[] { ',', '<', '>' }); + if (tmps.Length < 3) + { + x=y=z=0; + return; + } + bool res; + res = Double.TryParse(tmps[0], out x); + res = res & Double.TryParse(tmps[1], out y); + res = res & Double.TryParse(tmps[2], out z); + } + + #endregion + + #region Overriders + + public override string ToString() + { + string s=String.Format("<{0:0.000000},{1:0.000000},{2:0.000000}>", x, y, z); + return s; + } + + public static explicit operator LSLString(Vector3 vec) + { + string s=String.Format("<{0:0.000000},{1:0.000000},{2:0.000000}>", vec.x, vec.y, vec.z); + return new LSLString(s); + } + + public static explicit operator string(Vector3 vec) + { + string s=String.Format("<{0:0.000000},{1:0.000000},{2:0.000000}>", vec.x, vec.y, vec.z); + return s; + } + + public static explicit operator Vector3(string s) + { + return new Vector3(s); + } + + public static bool operator ==(Vector3 lhs, Vector3 rhs) + { + return (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z); + } + + public static bool operator !=(Vector3 lhs, Vector3 rhs) + { + return !(lhs == rhs); + } + + public override int GetHashCode() + { + return (x.GetHashCode() ^ y.GetHashCode() ^ z.GetHashCode()); + } + + public override bool Equals(object o) + { + if (!(o is Vector3)) return false; + + Vector3 vector = (Vector3)o; + + return (x == vector.x && x == vector.x && z == vector.z); + } + + #endregion + + #region Vector & Vector Math + + // Vector-Vector Math + public static Vector3 operator +(Vector3 lhs, Vector3 rhs) + { + return new Vector3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); + } + + public static Vector3 operator -(Vector3 lhs, Vector3 rhs) + { + return new Vector3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); + } + + public static Vector3 operator *(Vector3 lhs, Vector3 rhs) + { + return new Vector3(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z); + } + + public static Vector3 operator %(Vector3 v1, Vector3 v2) + { + //Cross product + Vector3 tv; + tv.x = (v1.y * v2.z) - (v1.z * v2.y); + tv.y = (v1.z * v2.x) - (v1.x * v2.z); + tv.z = (v1.x * v2.y) - (v1.y * v2.x); + return tv; + } + + #endregion + + #region Vector & Float Math + + // Vector-Float and Float-Vector Math + public static Vector3 operator *(Vector3 vec, float val) + { + return new Vector3(vec.x * val, vec.y * val, vec.z * val); + } + + public static Vector3 operator *(float val, Vector3 vec) + { + return new Vector3(vec.x * val, vec.y * val, vec.z * val); + } + + public static Vector3 operator /(Vector3 v, float f) + { + v.x = v.x / f; + v.y = v.y / f; + v.z = v.z / f; + return v; + } + + #endregion + + #region Vector & Double Math + + public static Vector3 operator *(Vector3 vec, double val) + { + return new Vector3(vec.x * val, vec.y * val, vec.z * val); + } + + public static Vector3 operator *(double val, Vector3 vec) + { + return new Vector3(vec.x * val, vec.y * val, vec.z * val); + } + + public static Vector3 operator /(Vector3 v, double f) + { + v.x = v.x / f; + v.y = v.y / f; + v.z = v.z / f; + return v; + } + + #endregion + + #region Vector & Rotation Math + + // Vector-Rotation Math + public static Vector3 operator *(Vector3 v, Quaternion r) + { + Quaternion vq = new Quaternion(v.x, v.y, v.z, 0); + Quaternion nq = new Quaternion(-r.x, -r.y, -r.z, r.s); + + // adapted for operator * computing "b * a" + Quaternion result = nq * (vq * r); + + return new Vector3(result.x, result.y, result.z); + } + + public static Vector3 operator /(Vector3 v, Quaternion r) + { + r.s = -r.s; + return v * r; + } + + #endregion + + #region Static Helper Functions + + public static double Dot(Vector3 v1, Vector3 v2) + { + return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z); + } + + public static Vector3 Cross(Vector3 v1, Vector3 v2) + { + return new Vector3 + ( + v1.y * v2.z - v1.z * v2.y, + v1.z * v2.x - v1.x * v2.z, + v1.x * v2.y - v1.y * v2.x + ); + } + + public static double Mag(Vector3 v) + { + return Math.Sqrt(v.x * v.x + v.y * v.y + v.z * v.z); + } + + public static Vector3 Norm(Vector3 vector) + { + double mag = Mag(vector); + return new Vector3(vector.x / mag, vector.y / mag, vector.z / mag); + } + + #endregion + } + + [Serializable] + public struct Quaternion + { + public double x; + public double y; + public double z; + public double s; + + #region Constructors + + public Quaternion(Quaternion Quat) + { + x = (float)Quat.x; + y = (float)Quat.y; + z = (float)Quat.z; + s = (float)Quat.s; + if (x == 0 && y == 0 && z == 0 && s == 0) + s = 1; + } + + public Quaternion(double X, double Y, double Z, double S) + { + x = X; + y = Y; + z = Z; + s = S; + if (x == 0 && y == 0 && z == 0 && s == 0) + s = 1; + } + + public Quaternion(string str) + { + str = str.Replace('<', ' '); + str = str.Replace('>', ' '); + string[] tmps = str.Split(new Char[] { ',', '<', '>' }); + if (tmps.Length < 4) + { + x=y=z=s=0; + return; + } + bool res; + res = Double.TryParse(tmps[0], out x); + res = res & Double.TryParse(tmps[1], out y); + res = res & Double.TryParse(tmps[2], out z); + res = res & Double.TryParse(tmps[3], out s); + if (x == 0 && y == 0 && z == 0 && s == 0) + s = 1; + } + + #endregion + + #region Overriders + + public override int GetHashCode() + { + return (x.GetHashCode() ^ y.GetHashCode() ^ z.GetHashCode() ^ s.GetHashCode()); + } + + public override bool Equals(object o) + { + if (!(o is Quaternion)) return false; + + Quaternion quaternion = (Quaternion)o; + + return x == quaternion.x && y == quaternion.y && z == quaternion.z && s == quaternion.s; + } + + public override string ToString() + { + string st=String.Format("<{0:0.000000},{1:0.000000},{2:0.000000},{3:0.000000}>", x, y, z, s); + return st; + } + + public static explicit operator string(Quaternion r) + { + string s=String.Format("<{0:0.000000},{1:0.000000},{2:0.000000},{3:0.000000}>", r.x, r.y, r.z, r.s); + return s; + } + + public static explicit operator LSLString(Quaternion r) + { + string s=String.Format("<{0:0.000000},{1:0.000000},{2:0.000000},{3:0.000000}>", r.x, r.y, r.z, r.s); + return new LSLString(s); + } + + public static explicit operator Quaternion(string s) + { + return new Quaternion(s); + } + + public static bool operator ==(Quaternion lhs, Quaternion rhs) + { + // Return true if the fields match: + return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z && lhs.s == rhs.s; + } + + public static bool operator !=(Quaternion lhs, Quaternion rhs) + { + return !(lhs == rhs); + } + + #endregion + + public static Quaternion operator +(Quaternion a, Quaternion b) + { + return new Quaternion(a.x + b.x, a.y + b.y, a.z + b.z, a.s + b.s); + } + + public static Quaternion operator /(Quaternion a, Quaternion b) + { + b.s = -b.s; + return a * b; + } + + public static Quaternion operator -(Quaternion a, Quaternion b) + { + return new Quaternion(a.x - b.x, a.y - b.y, a.z - b.z, a.s - b.s); + } + + // using the equations below, we need to do "b * a" to be compatible with LSL + public static Quaternion operator *(Quaternion b, Quaternion a) + { + Quaternion c; + c.x = a.s * b.x + a.x * b.s + a.y * b.z - a.z * b.y; + c.y = a.s * b.y + a.y * b.s + a.z * b.x - a.x * b.z; + c.z = a.s * b.z + a.z * b.s + a.x * b.y - a.y * b.x; + c.s = a.s * b.s - a.x * b.x - a.y * b.y - a.z * b.z; + return c; + } + } + + [Serializable] + public class list + { + private object[] m_data; + + public list(params object[] args) + { + m_data = new object[args.Length]; + m_data = args; + } + + public int Length + { + get { + if (m_data == null) + m_data=new Object[0]; + return m_data.Length; + } + } + + public object[] Data + { + get { + if (m_data == null) + m_data=new Object[0]; + return m_data; + } + } + + public static list operator +(list a, list b) + { + object[] tmp; + tmp = new object[a.Length + b.Length]; + a.Data.CopyTo(tmp, 0); + b.Data.CopyTo(tmp, a.Length); + return new list(tmp); + } + + private void ExtendAndAdd(object o) + { + Array.Resize(ref m_data, Length + 1); + m_data.SetValue(o, Length - 1); + } + + public static list operator +(list a, string s) + { + a.ExtendAndAdd(s); + return a; + } + + public static list operator +(list a, int i) + { + a.ExtendAndAdd(i); + return a; + } + + public static list operator +(list a, double d) + { + a.ExtendAndAdd(d); + return a; + } + + public void Add(object o) + { + object[] tmp; + tmp = new object[m_data.Length + 1]; + m_data.CopyTo(tmp, 0); + tmp[m_data.Length] = o; + m_data = tmp; + } + + public bool Contains(object o) + { + bool ret = false; + foreach (object i in Data) + { + if (i == o) + { + ret = true; + break; + } + } + return ret; + } + + public list DeleteSublist(int start, int end) + { + // Not an easy one + // If start <= end, remove that part + // if either is negative, count from the end of the array + // if the resulting start > end, remove all BUT that part + + Object[] ret; + + if (start < 0) + start=m_data.Length-start; + + if (start < 0) + start=0; + + if (end < 0) + end=m_data.Length-end; + if (end < 0) + end=0; + + if (start > end) + { + if (end >= m_data.Length) + return new list(new Object[0]); + + if (start >= m_data.Length) + start=m_data.Length-1; + + return GetSublist(end, start); + } + + // start >= 0 && end >= 0 here + if (start >= m_data.Length) + { + ret=new Object[m_data.Length]; + Array.Copy(m_data, 0, ret, 0, m_data.Length); + + return new list(ret); + } + + if (end >= m_data.Length) + end=m_data.Length-1; + + // now, this makes the math easier + int remove=end+1-start; + + ret=new Object[m_data.Length-remove]; + if (ret.Length == 0) + return new list(ret); + + int src; + int dest=0; + + for (src = 0; src < m_data.Length; src++) + { + if (src < start || src > end) + ret[dest++]=m_data[src]; + } + + return new list(ret); + } + + public list GetSublist(int start, int end) + { + + object[] ret; + + // Take care of neg start or end's + // NOTE that either index may still be negative after + // adding the length, so we must take additional + // measures to protect against this. Note also that + // after normalisation the negative indices are no + // longer relative to the end of the list. + + if (start < 0) + { + start = m_data.Length + start; + } + + if (end < 0) + { + end = m_data.Length + end; + } + + // The conventional case is start <= end + // NOTE that the case of an empty list is + // dealt with by the initial test. Start + // less than end is taken to be the most + // common case. + + if (start <= end) + { + + // Start sublist beyond length + // Also deals with start AND end still negative + if (start >= m_data.Length || end < 0) + { + return new list(); + } + + // Sublist extends beyond the end of the supplied list + if (end >= m_data.Length) + { + end = m_data.Length - 1; + } + + // Sublist still starts before the beginning of the list + if (start < 0) + { + start = 0; + } + + ret = new object[end - start + 1]; + + Array.Copy(m_data, start, ret, 0, end - start + 1); + + return new list(ret); + + } + + // Deal with the segmented case: 0->end + start->EOL + + else + { + + list result = null; + + // If end is negative, then prefix list is empty + if (end < 0) + { + result = new list(); + // If start is still negative, then the whole of + // the existing list is returned. This case is + // only admitted if end is also still negative. + if (start < 0) + { + return this; + } + + } + else + { + result = GetSublist(0,end); + } + + // If start is outside of list, then just return + // the prefix, whatever it is. + if (start >= m_data.Length) + { + return result; + } + + return result + GetSublist(start, Data.Length); + + } + } + + public list Sort(int stride, int ascending) + { + if (Data.Length == 0) + return new list(); // Don't even bother + + string[] keys; + + if (stride == 1) // The simple case + { + Object[] ret=new Object[Data.Length]; + + Array.Copy(Data, 0, ret, 0, Data.Length); + + keys=new string[Data.Length]; + + for (int k = 0; k < Data.Length; k++) + keys[k] = Data[k].ToString(); + + Array.Sort(keys, ret); + + if (ascending == 0) + Array.Reverse(ret); + return new list(ret); + } + + int src=0; + + int len=(Data.Length+stride-1)/stride; + + keys=new string[len]; + Object[][] vals=new Object[len][]; + + int i; + + while (src < Data.Length) + { + Object[] o=new Object[stride]; + + for (i = 0; i < stride; i++) + { + if (src < Data.Length) + o[i]=Data[src++]; + else + { + o[i]=new Object(); + src++; + } + } + + int idx=src/stride-1; + keys[idx]=o[0].ToString(); + vals[idx]=o; + } + + Array.Sort(keys, vals); + if (ascending == 0) + { + Array.Reverse(vals); + } + + Object[] sorted=new Object[stride*vals.Length]; + + for (i = 0; i < vals.Length; i++) + for (int j = 0; j < stride; j++) + sorted[i*stride+j] = vals[i][j]; + + return new list(sorted); + } + + #region CSV Methods + + public static list FromCSV(string csv) + { + return new list(csv.Split(',')); + } + + public string ToCSV() + { + string ret = ""; + foreach (object o in this.Data) + { + if (ret == "") + { + ret = o.ToString(); + } + else + { + ret = ret + ", " + o.ToString(); + } + } + return ret; + } + + private string ToSoup() + { + string output; + output = String.Empty; + if (m_data.Length == 0) + { + return String.Empty; + } + foreach (object o in m_data) + { + output = output + o.ToString(); + } + return output; + } + + public static explicit operator String(list l) + { + return l.ToSoup(); + } + + public static explicit operator LSLString(list l) + { + return new LSLString(l.ToSoup()); + } + + public override string ToString() + { + return ToSoup(); + } + + #endregion + + #region Statistic Methods + + public double Min() + { + double minimum = double.PositiveInfinity; + double entry; + for (int i = 0; i < Data.Length; i++) + { + if (double.TryParse(Data[i].ToString(), out entry)) + { + if (entry < minimum) minimum = entry; + } + } + return minimum; + } + + public double Max() + { + double maximum = double.NegativeInfinity; + double entry; + for (int i = 0; i < Data.Length; i++) + { + if (double.TryParse(Data[i].ToString(), out entry)) + { + if (entry > maximum) maximum = entry; + } + } + return maximum; + } + + public double Range() + { + return (this.Max() / this.Min()); + } + + public int NumericLength() + { + int count = 0; + double entry; + for (int i = 0; i < Data.Length; i++) + { + if (double.TryParse(Data[i].ToString(), out entry)) + { + count++; + } + } + return count; + } + + public static list ToDoubleList(list src) + { + list ret = new list(); + double entry; + for (int i = 0; i < src.Data.Length - 1; i++) + { + if (double.TryParse(src.Data[i].ToString(), out entry)) + { + ret.Add(entry); + } + } + return ret; + } + + public double Sum() + { + double sum = 0; + double entry; + for (int i = 0; i < Data.Length; i++) + { + if (double.TryParse(Data[i].ToString(), out entry)) + { + sum = sum + entry; + } + } + return sum; + } + + public double SumSqrs() + { + double sum = 0; + double entry; + for (int i = 0; i < Data.Length; i++) + { + if (double.TryParse(Data[i].ToString(), out entry)) + { + sum = sum + Math.Pow(entry, 2); + } + } + return sum; + } + + public double Mean() + { + return (this.Sum() / this.NumericLength()); + } + + public void NumericSort() + { + IComparer Numeric = new NumericComparer(); + Array.Sort(Data, Numeric); + } + + public void AlphaSort() + { + IComparer Alpha = new AlphaCompare(); + Array.Sort(Data, Alpha); + } + + public double Median() + { + return Qi(0.5); + } + + public double GeometricMean() + { + double ret = 1.0; + list nums = ToDoubleList(this); + for (int i = 0; i < nums.Data.Length; i++) + { + ret *= (double)nums.Data[i]; + } + return Math.Exp(Math.Log(ret) / (double)nums.Data.Length); + } + + public double HarmonicMean() + { + double ret = 0.0; + list nums = ToDoubleList(this); + for (int i = 0; i < nums.Data.Length; i++) + { + ret += 1.0 / (double)nums.Data[i]; + } + return ((double)nums.Data.Length / ret); + } + + public double Variance() + { + double s = 0; + list num = ToDoubleList(this); + for (int i = 0; i < num.Data.Length; i++) + { + s += Math.Pow((double)num.Data[i], 2); + } + return (s - num.Data.Length * Math.Pow(num.Mean(), 2)) / (num.Data.Length - 1); + } + + public double StdDev() + { + return Math.Sqrt(this.Variance()); + } + + public double Qi(double i) + { + list j = this; + j.NumericSort(); + + if (Math.Ceiling(this.Length * i) == this.Length * i) + { + return (double)((double)j.Data[(int)(this.Length * i - 1)] + (double)j.Data[(int)(this.Length * i)]) / 2; + } + else + { + return (double)j.Data[((int)(Math.Ceiling(this.Length * i))) - 1]; + } + } + + #endregion + + public string ToPrettyString() + { + string output; + if (m_data.Length == 0) + { + return "[]"; + } + output = "["; + foreach (object o in m_data) + { + if (o is String) + { + output = output + "\"" + o + "\", "; + } + else + { + output = output + o.ToString() + ", "; + } + } + output = output.Substring(0, output.Length - 2); + output = output + "]"; + return output; + } + + public class AlphaCompare : IComparer + { + int IComparer.Compare(object x, object y) + { + return string.Compare(x.ToString(), y.ToString()); + } + } + + public class NumericComparer : IComparer + { + int IComparer.Compare(object x, object y) + { + double a; + double b; + if (!double.TryParse(x.ToString(), out a)) + { + a = 0.0; + } + if (!double.TryParse(y.ToString(), out b)) + { + b = 0.0; + } + if (a < b) + { + return -1; + } + else if (a == b) + { + return 0; + } + else + { + return 1; + } + } + } + + } + + // + // BELOW IS WORK IN PROGRESS... IT WILL CHANGE, SO DON'T USE YET! :) + // + + public struct StringTest + { + // Our own little string + internal string actualString; + public static implicit operator bool(StringTest mString) + { + if (mString.actualString.Length == 0) + return true; + return false; + } + public override string ToString() + { + return actualString; + } + + } + + [Serializable] + public struct key + { + public string value; + + #region Constructors + public key(string s) + { + value = s; + } + + #endregion + + #region Methods + + static public bool Parse2Key(string s) + { + Regex isuuid = new Regex(@"^[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}$", RegexOptions.Compiled); + if (isuuid.IsMatch(s)) + { + return true; + } + else + { + return false; + } + } + + #endregion + + #region Operators + + static public implicit operator Boolean(key k) + { + if (k.value.Length == 0) + { + return false; + } + + if (k.value == "00000000-0000-0000-0000-000000000000") + { + return false; + } + Regex isuuid = new Regex(@"^[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}$", RegexOptions.Compiled); + if (isuuid.IsMatch(k.value)) + { + return true; + } + else + { + return false; + } + } + + static public implicit operator key(string s) + { + return new key(s); + } + + static public implicit operator String(key k) + { + return k.value; + } + + public static bool operator ==(key k1, key k2) + { + return k1.value == k2.value; + } + public static bool operator !=(key k1, key k2) + { + return k1.value != k2.value; + } + + #endregion + + #region Overriders + + public override bool Equals(object o) + { + return o.ToString() == value; + } + + public override int GetHashCode() + { + return value.GetHashCode(); + } + + #endregion + } + + [Serializable] + public struct LSLString + { + public string m_string; + #region Constructors + public LSLString(string s) + { + m_string = s; + } + + public LSLString(int i) + { + m_string=i.ToString(); + } + + public LSLString(double d) + { + string s=String.Format("{0:0.000000}", d); + m_string=s; + } + + public LSLString(LSLFloat f) + { + string s=String.Format("{0:0.000000}", f.value); + m_string=s; + } + + #endregion + + #region Operators + static public implicit operator Boolean(LSLString s) + { + if (s.m_string.Length == 0) + { + return false; + } + else + { + return true; + } + } + + + + static public implicit operator String(LSLString s) + { + return s.m_string; + } + + static public implicit operator LSLString(string s) + { + return new LSLString(s); + } + + public static string ToString(LSLString s) + { + return s.m_string; + } + + public override string ToString() + { + return m_string; + } + + public static bool operator ==(LSLString s1, string s2) + { + return s1.m_string == s2; + } + + public static bool operator !=(LSLString s1, string s2) + { + return s1.m_string != s2; + } + + public static explicit operator double(LSLString s) + { + return Convert.ToDouble(s.m_string); + } + + public static explicit operator LSLInteger(LSLString s) + { + return new LSLInteger(Convert.ToInt32(s.m_string)); + } + + public static explicit operator LSLString(int i) + { + return new LSLString(i); + } + + public static explicit operator LSLString(double d) + { + return new LSLString(d); + } + + public static explicit operator LSLString(LSLFloat f) + { + return new LSLString(f); + } + + public static implicit operator Vector3(LSLString s) + { + return new Vector3(s.m_string); + } + + #endregion + + #region Overriders + public override bool Equals(object o) + { + return m_string == o.ToString(); + } + + public override int GetHashCode() + { + return m_string.GetHashCode(); + } + + #endregion + + #region " Standard string functions " + //Clone,CompareTo,Contains + //CopyTo,EndsWith,Equals,GetEnumerator,GetHashCode,GetType,GetTypeCode + //IndexOf,IndexOfAny,Insert,IsNormalized,LastIndexOf,LastIndexOfAny + //Length,Normalize,PadLeft,PadRight,Remove,Replace,Split,StartsWith,Substring,ToCharArray,ToLowerInvariant + //ToString,ToUpper,ToUpperInvariant,Trim,TrimEnd,TrimStart + public bool Contains(string value) { return m_string.Contains(value); } + public int IndexOf(string value) { return m_string.IndexOf(value); } + public int Length { get { return m_string.Length; } } + + + #endregion + } + + [Serializable] + public struct LSLInteger + { + public int value; + + #region Constructors + public LSLInteger(int i) + { + value = i; + } + + public LSLInteger(double d) + { + value = (int)d; + } + + public LSLInteger(Object o) + { + if (!(o is Int32)) + value = 0; + else + value = (int)o; + } + + public LSLInteger(string s) + { + value = int.Parse(s); + } + + #endregion + + #region Operators + + static public implicit operator int(LSLInteger i) + { + return i.value; + } + + static public implicit operator uint(LSLInteger i) + { + return (uint)i.value; + } + + static public explicit operator LSLString(LSLInteger i) + { + return new LSLString(i.ToString()); + } + + static public explicit operator string(LSLInteger i) + { + return i.ToString(); + } + + static public implicit operator Boolean(LSLInteger i) + { + if (i.value == 0) + { + return false; + } + else + { + return true; + } + } + + static public implicit operator LSLInteger(int i) + { + return new LSLInteger(i); + } + + static public explicit operator LSLInteger(string s) + { + return new LSLInteger(int.Parse(s)); + } + + static public implicit operator LSLInteger(double d) + { + return new LSLInteger(d); + } + + static public bool operator ==(LSLInteger i1, LSLInteger i2) + { + bool ret = i1.value == i2.value; + return ret; + } + + static public bool operator !=(LSLInteger i1, LSLInteger i2) + { + bool ret = i1.value != i2.value; + return ret; + } + + static public LSLInteger operator &(LSLInteger i1, LSLInteger i2) + { + int ret = i1.value & i2.value; + return ret; + } + + public static LSLInteger operator ++(LSLInteger i) + { + i.value++; + return i; + } + + + public static LSLInteger operator --(LSLInteger i) + { + i.value--; + return i; + } + + static public implicit operator System.Double(LSLInteger i) + { + return (double)i.value; + } + + static public implicit operator LSLFloat(LSLInteger i) + { + return new LSLFloat((double)i.value); + } + + public static bool operator true(LSLInteger i) + { + return i.value != 0; + } + + public static bool operator false(LSLInteger i) + { + return i.value == 0; + } + + #endregion + + #region Overriders + + public override string ToString() + { + return this.value.ToString(); + } + + public override bool Equals(object o) + { + if (o is Int32) + { + return value == (Int32)o; + } + if (o is LSLInteger) + { + return value == ((LSLInteger)o).value; + } + return false; + } + + public override int GetHashCode() + { + return value.GetHashCode(); + } + + #endregion + } + + [Serializable] + public struct LSLFloat + { + public double value; + + #region Constructors + + public LSLFloat(int i) + { + value = (double)i; + } + + public LSLFloat(double d) + { + value = d; + } + + public LSLFloat(string s) + { + value = double.Parse(s); + } + + public LSLFloat(Object o) + { + if (!((o is double) || (o is float))) + { + value = 0.0; + return; + } + + value = (double)o; + } + + #endregion + + #region Operators + + static public implicit operator int(LSLFloat f) + { + return (int)f.value; + } + + static public implicit operator uint(LSLFloat f) + { + return (uint) Math.Abs(f.value); + } + + static public implicit operator Boolean(LSLFloat f) + { + if (f.value == 0.0) + { + return false; + } + else + { + return true; + } + } + + static public implicit operator LSLFloat(int i) + { + return new LSLFloat(i); + } + + static public implicit operator LSLFloat(string s) + { + return new LSLFloat(double.Parse(s)); + } + + static public implicit operator LSLFloat(double d) + { + return new LSLFloat(d); + } + + static public bool operator ==(LSLFloat f1, LSLFloat f2) + { + return f1.value == f2.value; + } + + static public bool operator !=(LSLFloat f1, LSLFloat f2) + { + return f1.value != f2.value; + } + + public override bool Equals(Object o) + { + if(!(o is LSLFloat)) + return false; + + return value == ((LSLFloat)o).value; + } + + public override int GetHashCode() + { + return (int)value; + } + + static public LSLFloat operator ++(LSLFloat f) + { + f.value++; + return f; + } + + static public LSLFloat operator --(LSLFloat f) + { + f.value--; + return f; + } + + static public implicit operator System.Double(LSLFloat f) + { + return f.value; + } + + #endregion + + #region Overriders + + public override string ToString() + { + return String.Format("{0:0.000000}", this.value); + } + + #endregion + } + } +} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandManager.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandManager.cs deleted file mode 100644 index fdad5b0..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandManager.cs +++ /dev/null @@ -1,268 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using System.Collections; -using System.Collections.Generic; -using System.Threading; -using libsecondlife; -using OpenSim.Framework; -using OpenSim.Region.Environment.Interfaces; -using OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins; -using Timer=OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins.Timer; -using Dataserver=OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins.Dataserver; - -namespace OpenSim.Region.ScriptEngine.XEngine -{ - /// - /// Handles LSL commands that takes long time and returns an event, for example timers, HTTP requests, etc. - /// - public class AsyncCommandManager - { - private static Thread cmdHandlerThread; - private static int cmdHandlerThreadCycleSleepms; - - public XEngine m_ScriptEngine; - - public Dataserver m_Dataserver; - public Timer m_Timer; - public HttpRequest m_HttpRequest; - public Listener m_Listener; - public SensorRepeat m_SensorRepeat; - public XmlRequest m_XmlRequest; - - public AsyncCommandManager(XEngine _ScriptEngine) - { - m_ScriptEngine = _ScriptEngine; - ReadConfig(); - - // Create instances of all plugins - m_Dataserver = new Dataserver(this); - m_Timer = new Timer(this); - m_HttpRequest = new HttpRequest(this); - m_Listener = new Listener(this); - m_SensorRepeat = new SensorRepeat(this); - m_XmlRequest = new XmlRequest(this); - - StartThread(); - } - - private static void StartThread() - { - if (cmdHandlerThread == null) - { - // Start the thread that will be doing the work - cmdHandlerThread = new Thread(CmdHandlerThreadLoop); - cmdHandlerThread.Name = "AsyncLSLCmdHandlerThread"; - cmdHandlerThread.Priority = ThreadPriority.BelowNormal; - cmdHandlerThread.IsBackground = true; - cmdHandlerThread.Start(); - ThreadTracker.Add(cmdHandlerThread); - } - } - - public void ReadConfig() - { - cmdHandlerThreadCycleSleepms = m_ScriptEngine.ScriptConfigSource.GetInt("AsyncLLCommandLoopms", 100); - } - - ~AsyncCommandManager() - { - // Shut down thread - try - { - if (cmdHandlerThread != null) - { - if (cmdHandlerThread.IsAlive == true) - { - cmdHandlerThread.Abort(); - //cmdHandlerThread.Join(); - } - } - } - catch - { - } - } - - private static void CmdHandlerThreadLoop() - { - while (true) - { - try - { - while (true) - { - Thread.Sleep(cmdHandlerThreadCycleSleepms); - - foreach (XEngine xe in XEngine.ScriptEngines) - { - xe.m_ASYNCLSLCommandManager.DoOneCmdHandlerPass(); - } - } - } - catch - { - } - } - } - - internal void DoOneCmdHandlerPass() - { - // Check timers - m_Timer.CheckTimerEvents(); - // Check HttpRequests - m_HttpRequest.CheckHttpRequests(); - // Check XMLRPCRequests - m_XmlRequest.CheckXMLRPCRequests(); - // Check Listeners - m_Listener.CheckListeners(); - // Check Sensors - m_SensorRepeat.CheckSenseRepeaterEvents(); - // Check dataserver - m_Dataserver.ExpireRequests(); - } - - /// - /// Remove a specific script (and all its pending commands) - /// - /// - /// - public void RemoveScript(uint localID, LLUUID itemID) - { - // Remove a specific script - - // Remove dataserver events - m_Dataserver.RemoveEvents(localID, itemID); - - // Remove from: Timers - m_Timer.UnSetTimerEvents(localID, itemID); - - // Remove from: HttpRequest - IHttpRequests iHttpReq = - m_ScriptEngine.World.RequestModuleInterface(); - iHttpReq.StopHttpRequest(localID, itemID); - - IWorldComm comms = m_ScriptEngine.World.RequestModuleInterface(); - comms.DeleteListener(itemID); - - IXMLRPC xmlrpc = m_ScriptEngine.World.RequestModuleInterface(); - xmlrpc.DeleteChannels(itemID); - xmlrpc.CancelSRDRequests(itemID); - - // Remove Sensors - m_SensorRepeat.UnSetSenseRepeaterEvents(localID, itemID); - - } - - public Object[] GetSerializationData(LLUUID itemID) - { - List data = new List(); - - Object[] listeners=m_Listener.GetSerializationData(itemID); - if (listeners.Length > 0) - { - data.Add("listener"); - data.Add(listeners.Length); - data.AddRange(listeners); - } - - Object[] timers=m_Timer.GetSerializationData(itemID); - if (timers.Length > 0) - { - data.Add("timer"); - data.Add(timers.Length); - data.AddRange(timers); - } - - Object[] sensors=m_SensorRepeat.GetSerializationData(itemID); - if (sensors.Length > 0) - { - data.Add("sensor"); - data.Add(sensors.Length); - data.AddRange(sensors); - } - - return data.ToArray(); - } - - public void CreateFromData(uint localID, LLUUID itemID, LLUUID hostID, - Object[] data) - { - int idx = 0; - int len; - - while (idx < data.Length) - { - string type = data[idx].ToString(); - len = (int)data[idx+1]; - idx+=2; - - if (len > 0) - { - Object[] item = new Object[len]; - Array.Copy(data, idx, item, 0, len); - - idx+=len; - - switch (type) - { - case "listener": - m_Listener.CreateFromData(localID, itemID, hostID, - item); - break; - case "timer": - m_Timer.CreateFromData(localID, itemID, hostID, item); - break; - case "sensor": - m_SensorRepeat.CreateFromData(localID, itemID, hostID, - item); - break; - } - } - } - } - - #region Check llRemoteData channels - - #endregion - - #region Check llListeners - - #endregion - - /// - /// If set to true then threads and stuff should try to make a graceful exit - /// - public bool PleaseShutdown - { - get { return _PleaseShutdown; } - set { _PleaseShutdown = value; } - } - private bool _PleaseShutdown = false; - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Dataserver.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Dataserver.cs deleted file mode 100644 index 47ab420..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Dataserver.cs +++ /dev/null @@ -1,127 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using System.Collections; -using System.Collections.Generic; -using libsecondlife; -using OpenSim.Region.ScriptEngine.XEngine.Script; - -namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins -{ - public class Dataserver - { - public AsyncCommandManager m_CmdManager; - - private Dictionary DataserverRequests = - new Dictionary(); - - public Dataserver(AsyncCommandManager CmdManager) - { - m_CmdManager = CmdManager; - } - - private class DataserverRequest - { - public uint localID; - public LLUUID itemID; - - public LLUUID ID; - public string handle; - - public DateTime startTime; - } - - public LLUUID RegisterRequest(uint localID, LLUUID itemID, - string identifier) - { - lock (DataserverRequests) - { - if (DataserverRequests.ContainsKey(identifier)) - return LLUUID.Zero; - - DataserverRequest ds = new DataserverRequest(); - - ds.localID = localID; - ds.itemID = itemID; - - ds.ID = LLUUID.Random(); - ds.handle = identifier; - - ds.startTime = DateTime.Now; - - DataserverRequests[identifier]=ds; - - return ds.ID; - } - } - - public void DataserverReply(string identifier, string reply) - { - DataserverRequest ds; - - lock (DataserverRequests) - { - if (!DataserverRequests.ContainsKey(identifier)) - return; - - ds=DataserverRequests[identifier]; - DataserverRequests.Remove(identifier); - } - - m_CmdManager.m_ScriptEngine.PostObjectEvent(ds.localID, - new XEventParams("dataserver", new Object[] - { new LSL_Types.LSLString(ds.ID.ToString()), - new LSL_Types.LSLString(reply)}, - new XDetectParams[0])); - } - - public void RemoveEvents(uint localID, LLUUID itemID) - { - lock (DataserverRequests) - { - foreach (DataserverRequest ds in new List(DataserverRequests.Values)) - { - if (ds.itemID == itemID) - DataserverRequests.Remove(ds.handle); - } - } - } - - public void ExpireRequests() - { - lock (DataserverRequests) - { - foreach (DataserverRequest ds in new List(DataserverRequests.Values)) - { - if (ds.startTime > DateTime.Now.AddSeconds(30)) - DataserverRequests.Remove(ds.handle); - } - } - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Eventstream.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Eventstream.cs deleted file mode 100644 index dab7a0a..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Eventstream.cs +++ /dev/null @@ -1,75 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using System.Collections; -using System.Collections.Generic; -using libsecondlife; -using OpenSim.Region.Environment.Scenes; - -namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins -{ - public class Eventstream - { - public AsyncCommandManager m_CmdManager; - - private class Event - { - public uint LocalID; - public string EventName; - public Dictionary DetectParams; - } - - private Dictionary > m_Events = - new Dictionary >(); - - public Eventstream(AsyncCommandManager CmdManager) - { - m_CmdManager = CmdManager; - } - - public void AddObjectEvent(uint localID, string eventName, XDetectParams det) - { - SceneObjectPart part = m_CmdManager.m_ScriptEngine.World. - GetSceneObjectPart(localID); - - if (part == null) // Can't register events for non-prims - return; - - if (!part.ContainsScripts()) - return; - } - - public void RemoveObjectEvent(uint localID, string eventName, LLUUID id) - { - } - - public void RemoveObjects(uint localID) - { - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/HttpRequest.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/HttpRequest.cs deleted file mode 100644 index 089e016..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/HttpRequest.cs +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using OpenSim.Region.Environment.Interfaces; -using OpenSim.Region.Environment.Modules.Scripting.HttpRequest; -using OpenSim.Region.ScriptEngine.XEngine.Script; - -namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins -{ - public class HttpRequest - { - public AsyncCommandManager m_CmdManager; - - public HttpRequest(AsyncCommandManager CmdManager) - { - m_CmdManager = CmdManager; - } - - public void CheckHttpRequests() - { - if (m_CmdManager.m_ScriptEngine.World == null) - return; - - IHttpRequests iHttpReq = - m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); - - HttpRequestClass httpInfo = null; - - if (iHttpReq != null) - httpInfo = iHttpReq.GetNextCompletedRequest(); - - while (httpInfo != null) - { - //m_ScriptEngine.Log.Info("[AsyncLSL]:" + httpInfo.response_body + httpInfo.status); - - // Deliver data to prim's remote_data handler - // - // TODO: Returning null for metadata, since the lsl function - // only returns the byte for HTTP_BODY_TRUNCATED, which is not - // implemented here yet anyway. Should be fixed if/when maxsize - // is supported - - iHttpReq.RemoveCompletedRequest(httpInfo.reqID); - - object[] resobj = new object[] - { - new LSL_Types.LSLString(httpInfo.reqID.ToString()), - new LSL_Types.LSLInteger(httpInfo.status), - new LSL_Types.list(), - new LSL_Types.LSLString(httpInfo.response_body) - }; - - foreach (XEngine xe in XEngine.ScriptEngines) - { - if (xe.PostObjectEvent(httpInfo.localID, - new XEventParams("http_response", - resobj, new XDetectParams[0]))) - break; - } - httpInfo = iHttpReq.GetNextCompletedRequest(); - } - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Listener.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Listener.cs deleted file mode 100644 index 1144c00..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Listener.cs +++ /dev/null @@ -1,91 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using libsecondlife; -using OpenSim.Region.Environment.Interfaces; -using OpenSim.Region.Environment.Modules.Scripting.WorldComm; -using OpenSim.Region.ScriptEngine.XEngine.Script; - -namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins -{ - public class Listener - { - // private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); - - public AsyncCommandManager m_CmdManager; - - public Listener(AsyncCommandManager CmdManager) - { - m_CmdManager = CmdManager; - } - - public void CheckListeners() - { - if (m_CmdManager.m_ScriptEngine.World == null) - return; - IWorldComm comms = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); - - if (comms != null) - { - while (comms.HasMessages()) - { - ListenerInfo lInfo = comms.GetNextMessage(); - - //Deliver data to prim's listen handler - object[] resobj = new object[] - { - new LSL_Types.LSLInteger(lInfo.GetChannel()), - new LSL_Types.LSLString(lInfo.GetName()), - new LSL_Types.LSLString(lInfo.GetID().ToString()), - new LSL_Types.LSLString(lInfo.GetMessage()) - }; - - m_CmdManager.m_ScriptEngine.PostScriptEvent( - lInfo.GetItemID(), new XEventParams( - "listen", resobj, - new XDetectParams[0])); - } - } - } - - public Object[] GetSerializationData(LLUUID itemID) - { - IWorldComm comms = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); - - return comms.GetSerializationData(itemID); - } - - public void CreateFromData(uint localID, LLUUID itemID, LLUUID hostID, - Object[] data) - { - IWorldComm comms = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); - - comms.CreateFromData(localID, itemID, hostID, data); - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/SensorRepeat.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/SensorRepeat.cs deleted file mode 100644 index 8a25098..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/SensorRepeat.cs +++ /dev/null @@ -1,393 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using System.Collections.Generic; -using libsecondlife; -using OpenSim.Framework; -using OpenSim.Region.Environment.Scenes; -using OpenSim.Region.ScriptEngine.XEngine.Script; - -namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins -{ - public class SensorRepeat - { - public AsyncCommandManager m_CmdManager; - - public SensorRepeat(AsyncCommandManager CmdManager) - { - m_CmdManager = CmdManager; - } - - public Dictionary> SenseEvents = - new Dictionary>(); - private Object SenseLock = new Object(); - - // - // SenseRepeater and Sensors - // - private class SenseRepeatClass - { - public uint localID; - public LLUUID itemID; - public double interval; - public DateTime next; - - public string name; - public LLUUID keyID; - public int type; - public double range; - public double arc; - public SceneObjectPart host; - } - - private List SenseRepeaters = new List(); - private object SenseRepeatListLock = new object(); - - public void SetSenseRepeatEvent(uint m_localID, LLUUID m_itemID, - string name, LLUUID keyID, int type, double range, - double arc, double sec, SceneObjectPart host) - { - Console.WriteLine("SetSensorEvent"); - - // Always remove first, in case this is a re-set - UnSetSenseRepeaterEvents(m_localID, m_itemID); - if (sec == 0) // Disabling timer - return; - - // Add to timer - SenseRepeatClass ts = new SenseRepeatClass(); - ts.localID = m_localID; - ts.itemID = m_itemID; - ts.interval = sec; - ts.name = name; - ts.keyID = keyID; - ts.type = type; - ts.range = range; - ts.arc = arc; - ts.host = host; - - ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); - lock (SenseRepeatListLock) - { - SenseRepeaters.Add(ts); - } - } - - public void UnSetSenseRepeaterEvents(uint m_localID, LLUUID m_itemID) - { - // Remove from timer - lock (SenseRepeatListLock) - { - List NewSensors = new List(); - foreach (SenseRepeatClass ts in SenseRepeaters) - { - if (ts.localID != m_localID && ts.itemID != m_itemID) - { - NewSensors.Add(ts); - } - } - SenseRepeaters.Clear(); - SenseRepeaters = NewSensors; - } - } - - public void CheckSenseRepeaterEvents() - { - // Nothing to do here? - if (SenseRepeaters.Count == 0) - return; - - lock (SenseRepeatListLock) - { - // Go through all timers - foreach (SenseRepeatClass ts in SenseRepeaters) - { - // Time has passed? - if (ts.next.ToUniversalTime() < DateTime.Now.ToUniversalTime()) - { - SensorSweep(ts); - // set next interval - ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); - } - } - } // lock - } - - public void SenseOnce(uint m_localID, LLUUID m_itemID, - string name, LLUUID keyID, int type, - double range, double arc, SceneObjectPart host) - { - // Add to timer - SenseRepeatClass ts = new SenseRepeatClass(); - ts.localID = m_localID; - ts.itemID = m_itemID; - ts.interval = 0; - ts.name = name; - ts.keyID = keyID; - ts.type = type; - ts.range = range; - ts.arc = arc; - ts.host = host; - SensorSweep(ts); - } - - public LSL_Types.list GetSensorList(uint m_localID, LLUUID m_itemID) - { - lock (SenseLock) - { - Dictionary Obj = null; - if (!SenseEvents.TryGetValue(m_localID, out Obj)) - { - m_CmdManager.m_ScriptEngine.Log.Info("[AsyncLSL]: GetSensorList missing localID: " + m_localID); - return null; - } - lock (Obj) - { - // Get script - LSL_Types.list SenseList = null; - if (!Obj.TryGetValue(m_itemID, out SenseList)) - { - m_CmdManager.m_ScriptEngine.Log.Info("[AsyncLSL]: GetSensorList missing itemID: " + m_itemID); - return null; - } - return SenseList; - } - } - } - - private void SensorSweep(SenseRepeatClass ts) - { - //m_ScriptEngine.Log.Info("[AsyncLSL]:Enter SensorSweep"); - SceneObjectPart SensePoint = ts.host; - - if (SensePoint == null) - { - //m_ScriptEngine.Log.Info("[AsyncLSL]: Enter SensorSweep (SensePoint == null) for "+ts.itemID.ToString()); - return; - } - //m_ScriptEngine.Log.Info("[AsyncLSL]: Enter SensorSweep Scan"); - - LLVector3 sensorPos = SensePoint.AbsolutePosition; - LLVector3 regionPos = new LLVector3(m_CmdManager.m_ScriptEngine.World.RegionInfo.RegionLocX * Constants.RegionSize, m_CmdManager.m_ScriptEngine.World.RegionInfo.RegionLocY * Constants.RegionSize, 0); - LLVector3 fromRegionPos = sensorPos + regionPos; - - LLQuaternion q = SensePoint.RotationOffset; - LSL_Types.Quaternion r = new LSL_Types.Quaternion(q.X, q.Y, q.Z, q.W); - LSL_Types.Vector3 forward_dir = (new LSL_Types.Vector3(1, 0, 0) * r); - double mag_fwd = LSL_Types.Vector3.Mag(forward_dir); - - // Here we should do some smart culling ... - // math seems quicker than strings so try that first - LSL_Types.list SensedObjects = new LSL_Types.list(); - LSL_Types.Vector3 ZeroVector = new LSL_Types.Vector3(0, 0, 0); - - foreach (EntityBase ent in m_CmdManager.m_ScriptEngine.World.Entities.Values) - { - LLVector3 toRegionPos = ent.AbsolutePosition + regionPos; - double dis = Math.Abs((double)Util.GetDistanceTo(toRegionPos, fromRegionPos)); - if (dis <= ts.range) - { - // In Range, is it the right Type ? - int objtype = 0; - - if (m_CmdManager.m_ScriptEngine.World.GetScenePresence(ent.UUID) != null) objtype |= 0x01; // actor - if (ent.Velocity.Equals(ZeroVector)) - objtype |= 0x04; // passive non-moving - else - objtype |= 0x02; // active moving - if (ent is IScript) objtype |= 0x08; // Scripted. It COULD have one hidden ... - - if (((ts.type & objtype) != 0) || ((ts.type & objtype) == ts.type)) - { - // docs claim AGENT|ACTIVE should find agent objects OR active objects - // so the bitwise AND with object type should be non-zero - - // Right type too, what about the other params , key and name ? - bool keep = true; - if (ts.arc < Math.PI) - { - // not omni-directional. Can you see it ? - // vec forward_dir = llRot2Fwd(llGetRot()) - // vec obj_dir = toRegionPos-fromRegionPos - // dot=dot(forward_dir,obj_dir) - // mag_fwd = mag(forward_dir) - // mag_obj = mag(obj_dir) - // ang = acos(dot /(mag_fwd*mag_obj)) - double ang_obj = 0; - try - { - LLVector3 diff = toRegionPos - fromRegionPos; - LSL_Types.Vector3 obj_dir = new LSL_Types.Vector3(diff.X, diff.Y, diff.Z); - double dot = LSL_Types.Vector3.Dot(forward_dir, obj_dir); - double mag_obj = LSL_Types.Vector3.Mag(obj_dir); - ang_obj = Math.Acos(dot / (mag_fwd * mag_obj)); - } - catch - { - } - - if (ang_obj > ts.arc) keep = false; - } - - if (keep && (ts.keyID != LLUUID.Zero) && (ts.keyID != ent.UUID)) - { - keep = false; - } - - if (keep && (ts.name.Length > 0)) - { - string avatarname=null; - string objectname=null; - string entname =ent.Name; - - // try avatar username surname - UserProfileData profile = m_CmdManager.m_ScriptEngine.World.CommsManager.UserService.GetUserProfile(ent.UUID); - if (profile != null) - { - avatarname = profile.FirstName + " " + profile.SurName; - } - // try an scene object - SceneObjectPart SOP = m_CmdManager.m_ScriptEngine.World.GetSceneObjectPart(ent.UUID); - if (SOP != null) - { - objectname = SOP.Name; - } - - if ((ts.name != entname) && (ts.name != avatarname) && (ts.name != objectname)) - { - keep = false; - } - } - - if (keep == true) SensedObjects.Add(ent.UUID); - } - } - } - //m_ScriptEngine.Log.Info("[AsyncLSL]: Enter SensorSweep SenseLock"); - - lock (SenseLock) - { - // Create object if it doesn't exist - if (SenseEvents.ContainsKey(ts.localID) == false) - { - SenseEvents.Add(ts.localID, new Dictionary()); - } - // clear if previous traces exist - Dictionary Obj; - SenseEvents.TryGetValue(ts.localID, out Obj); - if (Obj.ContainsKey(ts.itemID) == true) - Obj.Remove(ts.itemID); - - // note list may be zero length - Obj.Add(ts.itemID, SensedObjects); - - if (SensedObjects.Length == 0) - { - // send a "no_sensor" - // Add it to queue - m_CmdManager.m_ScriptEngine.PostScriptEvent(ts.itemID, - new XEventParams("no_sensor", new Object[0], - new XDetectParams[0])); - } - else - { - XDetectParams[] detect = - new XDetectParams[SensedObjects.Length]; - - int idx; - for (idx = 0; idx < SensedObjects.Length; idx++) - { - detect[idx] = new XDetectParams(); - detect[idx].Key=(LLUUID)(SensedObjects.Data[idx]); - detect[idx].Populate(m_CmdManager.m_ScriptEngine.World); - } - - m_CmdManager.m_ScriptEngine.PostScriptEvent(ts.itemID, - new XEventParams("sensor", - new Object[] { - new LSL_Types.LSLInteger(SensedObjects.Length) }, - detect)); - } - } - } - - public Object[] GetSerializationData(LLUUID itemID) - { - List data = new List(); - - foreach (SenseRepeatClass ts in SenseRepeaters) - { - if (ts.itemID == itemID) - { - data.Add(ts.interval); - data.Add(ts.name); - data.Add(ts.keyID); - data.Add(ts.type); - data.Add(ts.range); - data.Add(ts.arc); - } - } - return data.ToArray(); - } - - public void CreateFromData(uint localID, LLUUID itemID, LLUUID objectID, - Object[] data) - { - SceneObjectPart part = - m_CmdManager.m_ScriptEngine.World.GetSceneObjectPart( - objectID); - - if (part == null) - return; - - int idx = 0; - - while (idx < data.Length) - { - SenseRepeatClass ts = new SenseRepeatClass(); - - ts.localID = localID; - ts.itemID = itemID; - - ts.interval = (double)data[idx]; - ts.name = (string)data[idx+1]; - ts.keyID = (LLUUID)data[idx+2]; - ts.type = (int)data[idx+3]; - ts.range = (double)data[idx+4]; - ts.arc = (double)data[idx+5]; - ts.host = part; - - ts.next = - DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); - - SenseRepeaters.Add(ts); - idx += 6; - } - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Timer.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Timer.cs deleted file mode 100644 index 3dd875a..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Timer.cs +++ /dev/null @@ -1,161 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using System.Collections; -using System.Collections.Generic; -using libsecondlife; - -namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins -{ - public class Timer - { - public AsyncCommandManager m_CmdManager; - - public Timer(AsyncCommandManager CmdManager) - { - m_CmdManager = CmdManager; - } - - // - // TIMER - // - private class TimerClass - { - public uint localID; - public LLUUID itemID; - //public double interval; - public long interval; - //public DateTime next; - public long next; - } - - private List Timers = new List(); - private object TimerListLock = new object(); - - public void SetTimerEvent(uint m_localID, LLUUID m_itemID, double sec) - { - // Always remove first, in case this is a re-set - UnSetTimerEvents(m_localID, m_itemID); - if (sec == 0) // Disabling timer - return; - - // Add to timer - TimerClass ts = new TimerClass(); - ts.localID = m_localID; - ts.itemID = m_itemID; - ts.interval = Convert.ToInt64(sec * 10000000); // How many 100 nanoseconds (ticks) should we wait - // 2193386136332921 ticks - // 219338613 seconds - - //ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); - ts.next = DateTime.Now.Ticks + ts.interval; - lock (TimerListLock) - { - Timers.Add(ts); - } - } - - public void UnSetTimerEvents(uint m_localID, LLUUID m_itemID) - { - // Remove from timer - lock (TimerListLock) - { - foreach (TimerClass ts in new ArrayList(Timers)) - { - if (ts.localID == m_localID && ts.itemID == m_itemID) - Timers.Remove(ts); - } - } - } - - public void CheckTimerEvents() - { - // Nothing to do here? - if (Timers.Count == 0) - return; - - lock (TimerListLock) - { - // Go through all timers - foreach (TimerClass ts in Timers) - { - // Time has passed? - if (ts.next < DateTime.Now.Ticks) - { - // Console.WriteLine("Time has passed: Now: " + DateTime.Now.Ticks + ", Passed: " + ts.next); - // Add it to queue - m_CmdManager.m_ScriptEngine.PostScriptEvent(ts.itemID, - new XEventParams("timer", new Object[0], - new XDetectParams[0])); - // set next interval - - //ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); - ts.next = DateTime.Now.Ticks + ts.interval; - } - } - } - } - - public Object[] GetSerializationData(LLUUID itemID) - { - List data = new List(); - - lock (TimerListLock) - { - foreach (TimerClass ts in Timers) - { - if (ts.itemID == itemID) - { - data.Add(ts.interval); - data.Add(ts.next-DateTime.Now.Ticks); - } - } - } - return data.ToArray(); - } - - public void CreateFromData(uint localID, LLUUID itemID, LLUUID objectID, - Object[] data) - { - int idx = 0; - - while (idx < data.Length) - { - TimerClass ts = new TimerClass(); - - ts.localID = localID; - ts.itemID = itemID; - ts.interval = (long)data[idx]; - ts.next = DateTime.Now.Ticks + (long)data[idx+1]; - idx += 2; - - Timers.Add(ts); - } - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/XmlRequest.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/XmlRequest.cs deleted file mode 100644 index 288349e..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/XmlRequest.cs +++ /dev/null @@ -1,115 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using OpenSim.Region.Environment.Interfaces; -using OpenSim.Region.Environment.Modules.Scripting.XMLRPC; -using OpenSim.Region.ScriptEngine.XEngine.Script; - -namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins -{ - public class XmlRequest - { - public AsyncCommandManager m_CmdManager; - - public XmlRequest(AsyncCommandManager CmdManager) - { - m_CmdManager = CmdManager; - } - - public void CheckXMLRPCRequests() - { - if (m_CmdManager.m_ScriptEngine.World == null) - return; - - IXMLRPC xmlrpc = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); - - if (xmlrpc != null) - { - RPCRequestInfo rInfo = xmlrpc.GetNextCompletedRequest(); - - while (rInfo != null) - { - xmlrpc.RemoveCompletedRequest(rInfo.GetMessageID()); - - //Deliver data to prim's remote_data handler - object[] resobj = new object[] - { - new LSL_Types.LSLInteger(2), - new LSL_Types.LSLString( - rInfo.GetChannelKey().ToString()), - new LSL_Types.LSLString( - rInfo.GetMessageID().ToString()), - new LSL_Types.LSLString(String.Empty), - new LSL_Types.LSLInteger(rInfo.GetIntValue()), - new LSL_Types.LSLString(rInfo.GetStrVal()) - }; - - foreach (XEngine xe in XEngine.ScriptEngines) - { - if (xe.PostScriptEvent( - rInfo.GetItemID(), new XEventParams( - "remote_data", resobj, - new XDetectParams[0]))) - break; - } - - rInfo = xmlrpc.GetNextCompletedRequest(); - } - - SendRemoteDataRequest srdInfo = xmlrpc.GetNextCompletedSRDRequest(); - - while (srdInfo != null) - { - xmlrpc.RemoveCompletedSRDRequest(srdInfo.GetReqID()); - - //Deliver data to prim's remote_data handler - object[] resobj = new object[] - { - new LSL_Types.LSLInteger(3), - new LSL_Types.LSLString(srdInfo.channel.ToString()), - new LSL_Types.LSLString(srdInfo.GetReqID().ToString()), - new LSL_Types.LSLString(String.Empty), - new LSL_Types.LSLInteger(srdInfo.idata), - new LSL_Types.LSLString(srdInfo.sdata) - }; - - foreach (XEngine xe in XEngine.ScriptEngines) - { - if (xe.PostScriptEvent( - srdInfo.m_itemID, new XEventParams( - "remote_data", resobj, - new XDetectParams[0]))) - break; - } - - srdInfo = xmlrpc.GetNextCompletedSRDRequest(); - } - } - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/Compiler.cs b/OpenSim/Region/ScriptEngine/XEngine/Compiler.cs deleted file mode 100644 index 68fb1dd..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/Compiler.cs +++ /dev/null @@ -1,515 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using System.CodeDom.Compiler; -using System.Collections.Generic; -using System.Globalization; -using System.IO; -using Microsoft.CSharp; -using Microsoft.JScript; -using Microsoft.VisualBasic; -using OpenSim.Region.Environment.Interfaces; - -namespace OpenSim.Region.ScriptEngine.XEngine -{ - public class Compiler - { - private static readonly log4net.ILog m_log - = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); - - // * Uses "LSL2Converter" to convert LSL to C# if necessary. - // * Compiles C#-code into an assembly - // * Returns assembly name ready for AppDomain load. - // - // Assembly is compiled using LSL_BaseClass as base. Look at debug C# code file created when LSL script is compiled for full details. - // - - internal enum enumCompileType - { - lsl = 0, - cs = 1, - vb = 2, - js = 3 - } - - /// - /// This contains number of lines WE use for header when compiling script. User will get error in line x-LinesToRemoveOnError when error occurs. - /// - public int LinesToRemoveOnError = 3; - private enumCompileType DefaultCompileLanguage; - private bool WriteScriptSourceToDebugFile; - private bool CompileWithDebugInformation; - private Dictionary AllowedCompilers = new Dictionary(StringComparer.CurrentCultureIgnoreCase); - private Dictionary LanguageMapping = new Dictionary(StringComparer.CurrentCultureIgnoreCase); - - private string FilePrefix; - private string ScriptEnginesPath = "ScriptEngines"; - - private static LSL2CSConverter LSL_Converter = new LSL2CSConverter(); - private static CSharpCodeProvider CScodeProvider = new CSharpCodeProvider(); - private static VBCodeProvider VBcodeProvider = new VBCodeProvider(); - private static JScriptCodeProvider JScodeProvider = new JScriptCodeProvider(); - - private static int instanceID = new Random().Next(0, int.MaxValue); // Unique number to use on our compiled files - private static UInt64 scriptCompileCounter = 0; // And a counter - - public XEngine m_scriptEngine; - public Compiler(XEngine scriptEngine) - { - m_scriptEngine = scriptEngine; - ReadConfig(); - } - public bool in_startup = true; - public void ReadConfig() - { - - // Get some config - WriteScriptSourceToDebugFile = m_scriptEngine.ScriptConfigSource.GetBoolean("WriteScriptSourceToDebugFile", true); - CompileWithDebugInformation = m_scriptEngine.ScriptConfigSource.GetBoolean("CompileWithDebugInformation", true); - - // Get file prefix from scriptengine name and make it file system safe: - FilePrefix = m_scriptEngine.ScriptEngineName; - foreach (char c in Path.GetInvalidFileNameChars()) - { - FilePrefix = FilePrefix.Replace(c, '_'); - } - - // First time we start? Delete old files - if (in_startup) - { - in_startup = false; - DeleteOldFiles(); - } - - // Map name and enum type of our supported languages - LanguageMapping.Add(enumCompileType.cs.ToString(), enumCompileType.cs); - LanguageMapping.Add(enumCompileType.vb.ToString(), enumCompileType.vb); - LanguageMapping.Add(enumCompileType.lsl.ToString(), enumCompileType.lsl); - LanguageMapping.Add(enumCompileType.js.ToString(), enumCompileType.js); - - // Allowed compilers - string allowComp = m_scriptEngine.ScriptConfigSource.GetString("AllowedCompilers", "lsl,cs,vb,js"); - AllowedCompilers.Clear(); - -#if DEBUG - m_scriptEngine.Log.Debug("[" + m_scriptEngine.ScriptEngineName + "]: Allowed languages: " + allowComp); -#endif - - - foreach (string strl in allowComp.Split(',')) - { - string strlan = strl.Trim(" \t".ToCharArray()).ToLower(); - if (!LanguageMapping.ContainsKey(strlan)) - { - m_scriptEngine.Log.Error("[" + m_scriptEngine.ScriptEngineName + "]: Config error. Compiler is unable to recognize language type \"" + strlan + "\" specified in \"AllowedCompilers\"."); - } - else - { -#if DEBUG - //m_scriptEngine.Log.Debug("[" + m_scriptEngine.ScriptEngineName + "]: Config OK. Compiler recognized language type \"" + strlan + "\" specified in \"AllowedCompilers\"."); -#endif - } - AllowedCompilers.Add(strlan, true); - } - if (AllowedCompilers.Count == 0) - m_scriptEngine.Log.Error("[" + m_scriptEngine.ScriptEngineName + "]: Config error. Compiler could not recognize any language in \"AllowedCompilers\". Scripts will not be executed!"); - - // Default language - string defaultCompileLanguage = m_scriptEngine.ScriptConfigSource.GetString("DefaultCompileLanguage", "lsl").ToLower(); - - // Is this language recognized at all? - if (!LanguageMapping.ContainsKey(defaultCompileLanguage)) - { - m_scriptEngine.Log.Error("[" + m_scriptEngine.ScriptEngineName + "]: " + - "Config error. Default language \"" + defaultCompileLanguage + "\" specified in \"DefaultCompileLanguage\" is not recognized as a valid language. Changing default to: \"lsl\"."); - defaultCompileLanguage = "lsl"; - } - - // Is this language in allow-list? - if (!AllowedCompilers.ContainsKey(defaultCompileLanguage)) - { - m_scriptEngine.Log.Error("[" + m_scriptEngine.ScriptEngineName + "]: " + - "Config error. Default language \"" + defaultCompileLanguage + "\"specified in \"DefaultCompileLanguage\" is not in list of \"AllowedCompilers\". Scripts may not be executed!"); - } - else - { -#if DEBUG -// m_scriptEngine.Log.Debug("[" + m_scriptEngine.ScriptEngineName + "]: " + -// "Config OK. Default language \"" + defaultCompileLanguage + "\" specified in \"DefaultCompileLanguage\" is recognized as a valid language."); -#endif - // LANGUAGE IS IN ALLOW-LIST - DefaultCompileLanguage = LanguageMapping[defaultCompileLanguage]; - } - - // We now have an allow-list, a mapping list, and a default language - - } - - /// - /// Delete old script files - /// - private void DeleteOldFiles() - { - - // CREATE FOLDER IF IT DOESNT EXIST - if (!Directory.Exists(ScriptEnginesPath)) - { - try - { - Directory.CreateDirectory(ScriptEnginesPath); - } - catch (Exception ex) - { - m_scriptEngine.Log.Error("[" + m_scriptEngine.ScriptEngineName + "]: Exception trying to create ScriptEngine directory \"" + ScriptEnginesPath + "\": " + ex.ToString()); - } - } - - if (!Directory.Exists(Path.Combine(ScriptEnginesPath, - m_scriptEngine.World.RegionInfo.RegionID.ToString()))) - { - try - { - Directory.CreateDirectory(Path.Combine(ScriptEnginesPath, - m_scriptEngine.World.RegionInfo.RegionID.ToString())); - } - catch (Exception ex) - { - m_scriptEngine.Log.Error("[" + m_scriptEngine.ScriptEngineName + "]: Exception trying to create ScriptEngine directory \"" + Path.Combine(ScriptEnginesPath, - m_scriptEngine.World.RegionInfo.RegionID.ToString())+ "\": " + ex.ToString()); - } - } - - foreach (string file in Directory.GetFiles(Path.Combine(ScriptEnginesPath, - m_scriptEngine.World.RegionInfo.RegionID.ToString()))) - { - //m_scriptEngine.Log.Error("[" + m_scriptEngine.ScriptEngineName + "]: FILE FOUND: " + file); - - if (file.ToLower().StartsWith(FilePrefix + "_compiled_") || - file.ToLower().StartsWith(FilePrefix + "_source_")) - { - try - { - File.Delete(file); - } - catch (Exception ex) - { - m_scriptEngine.Log.Error("[" + m_scriptEngine.ScriptEngineName + "]: Exception trying delete old script file \"" + file + "\": " + ex.ToString()); - } - - } - } - - } - - ////private ICodeCompiler icc = codeProvider.CreateCompiler(); - //public string CompileFromFile(string LSOFileName) - //{ - // switch (Path.GetExtension(LSOFileName).ToLower()) - // { - // case ".txt": - // case ".lsl": - // Common.ScriptEngineBase.Common.SendToDebug("Source code is LSL, converting to CS"); - // return CompileFromLSLText(File.ReadAllText(LSOFileName)); - // case ".cs": - // Common.ScriptEngineBase.Common.SendToDebug("Source code is CS"); - // return CompileFromCSText(File.ReadAllText(LSOFileName)); - // default: - // throw new Exception("Unknown script type."); - // } - //} - - /// - /// Converts script from LSL to CS and calls CompileFromCSText - /// - /// LSL script - /// Filename to .dll assembly - public string PerformScriptCompile(string Script, string asset) - { - string OutFile = Path.Combine(ScriptEnginesPath, Path.Combine( - m_scriptEngine.World.RegionInfo.RegionID.ToString(), - FilePrefix + "_compiled_" + asset + ".dll")); -// string OutFile = Path.Combine(ScriptEnginesPath, -// FilePrefix + "_compiled_" + asset + ".dll"); - - if (File.Exists(OutFile)) - { - m_scriptEngine.Log.DebugFormat("[XEngine] Returning existing assembly for {0}", asset); - return OutFile; - } - - if (!Directory.Exists(ScriptEnginesPath)) - { - try - { - Directory.CreateDirectory(ScriptEnginesPath); - } - catch (Exception ex) - { - } - } - - if (!Directory.Exists(Path.Combine(ScriptEnginesPath, - m_scriptEngine.World.RegionInfo.RegionID.ToString()))) - { - try - { - Directory.CreateDirectory(ScriptEnginesPath); - } - catch (Exception ex) - { - } - } - - enumCompileType l = DefaultCompileLanguage; - - if (Script.StartsWith("//c#", true, CultureInfo.InvariantCulture)) - l = enumCompileType.cs; - if (Script.StartsWith("//vb", true, CultureInfo.InvariantCulture)) - { - l = enumCompileType.vb; - // We need to remove //vb, it won't compile with that - - Script = Script.Substring(4, Script.Length - 4); - } - if (Script.StartsWith("//lsl", true, CultureInfo.InvariantCulture)) - l = enumCompileType.lsl; - - if (Script.StartsWith("//js", true, CultureInfo.InvariantCulture)) - l = enumCompileType.js; - - if (!AllowedCompilers.ContainsKey(l.ToString())) - { - // Not allowed to compile to this language! - string errtext = String.Empty; - errtext += "The compiler for language \"" + l.ToString() + "\" is not in list of allowed compilers. Script will not be executed!"; - throw new Exception(errtext); - } - - string compileScript = Script; - - if (l == enumCompileType.lsl) - { - // Its LSL, convert it to C# - compileScript = LSL_Converter.Convert(Script); - l = enumCompileType.cs; - } - - // Insert additional assemblies here - - //ADAM: Disabled for the moment until it's working right. - bool enableCommanderLSL = false; - - if (enableCommanderLSL == true && l == enumCompileType.cs) - { - foreach (KeyValuePair com - in m_scriptEngine.World.GetCommanders()) - { - compileScript = com.Value.GenerateRuntimeAPI() + compileScript; - } - } - - // End of insert - - switch (l) - { - case enumCompileType.cs: - compileScript = CreateCSCompilerScript(compileScript); - break; - case enumCompileType.vb: - compileScript = CreateVBCompilerScript(compileScript); - break; - case enumCompileType.js: - compileScript = CreateJSCompilerScript(compileScript); - break; - } - -// m_log.Debug("[ScriptEngine.DotNetEngine]: Preparing to compile the following LSL to C# translated code"); -// m_log.Debug(""); -// m_log.Debug(compileScript); - - return CompileFromDotNetText(compileScript, l, asset); - } - - private static string CreateJSCompilerScript(string compileScript) - { - compileScript = String.Empty + - "import OpenSim.Region.ScriptEngine.XEngine.Script; import System.Collections.Generic;\r\n" + - "package SecondLife {\r\n" + - "class Script extends OpenSim.Region.ScriptEngine.XEngine.Script.BuiltIn_Commands_BaseClass { \r\n" + - compileScript + - "} }\r\n"; - return compileScript; - } - - private static string CreateCSCompilerScript(string compileScript) - { - compileScript = String.Empty + - "using OpenSim.Region.ScriptEngine.XEngine.Script; using System.Collections.Generic;\r\n" + - String.Empty + "namespace SecondLife { " + - String.Empty + "public class Script : OpenSim.Region.ScriptEngine.XEngine.Script.BuiltIn_Commands_BaseClass { \r\n" + - @"public Script() { } " + - compileScript + - "} }\r\n"; - return compileScript; - } - - private static string CreateVBCompilerScript(string compileScript) - { - compileScript = String.Empty + - "Imports OpenSim.Region.ScriptEngine.XEngine.Script: Imports System.Collections.Generic: " + - String.Empty + "NameSpace SecondLife:" + - String.Empty + "Public Class Script: Inherits OpenSim.Region.ScriptEngine.XEngine.Script.BuiltIn_Commands_BaseClass: " + - "\r\nPublic Sub New()\r\nEnd Sub: " + - compileScript + - ":End Class :End Namespace\r\n"; - return compileScript; - } - - /// - /// Compile .NET script to .Net assembly (.dll) - /// - /// CS script - /// Filename to .dll assembly - internal string CompileFromDotNetText(string Script, enumCompileType lang, string asset) - { - string ext = "." + lang.ToString(); - - // Output assembly name - scriptCompileCounter++; - string OutFile = Path.Combine(ScriptEnginesPath, Path.Combine( - m_scriptEngine.World.RegionInfo.RegionID.ToString(), - FilePrefix + "_compiled_" + asset + ".dll")); -#if DEBUG -// m_scriptEngine.Log.Debug("[" + m_scriptEngine.ScriptEngineName + "]: Starting compile of \"" + OutFile + "\"."); -#endif - try - { - File.Delete(OutFile); - } - catch (Exception e) // NOTLEGIT - Should be just catching FileIOException - { - //m_scriptEngine.Log.Error("[" + m_scriptEngine.ScriptEngineName + "]: Unable to delete old existring script-file before writing new. Compile aborted: " + e.ToString()); - throw new Exception("Unable to delete old existring script-file before writing new. Compile aborted: " + e.ToString()); - } - //string OutFile = Path.Combine("ScriptEngines", "SecondLife.Script.dll"); - - // DEBUG - write source to disk - if (WriteScriptSourceToDebugFile) - { - string srcFileName = FilePrefix + "_source_" + Path.GetFileNameWithoutExtension(OutFile) + ext; - try - { - File.WriteAllText(Path.Combine(Path.Combine( - ScriptEnginesPath, - m_scriptEngine.World.RegionInfo.RegionID.ToString()), - srcFileName), Script); - } - catch (Exception ex) // NOTLEGIT - Should be just catching FileIOException - { - m_scriptEngine.Log.Error("[" + m_scriptEngine.ScriptEngineName + "]: Exception while trying to write script source to file \"" + srcFileName + "\": " + ex.ToString()); - } - } - - // Do actual compile - CompilerParameters parameters = new CompilerParameters(); - - parameters.IncludeDebugInformation = true; - - // Add all available assemblies -// foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies()) -// { -// Console.WriteLine("Adding assembly: " + asm.Location); -// parameters.ReferencedAssemblies.Add(asm.Location); -// } - - string rootPath = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory); - string rootPathSE = Path.GetDirectoryName(GetType().Assembly.Location); - //Console.WriteLine("Assembly location: " + rootPath); - parameters.ReferencedAssemblies.Add(Path.Combine(rootPath, "OpenSim.Region.ScriptEngine.XEngine.Script.dll")); -// parameters.ReferencedAssemblies.Add(Path.Combine(rootPathSE, "OpenSim.Region.ScriptEngine.XEngine.dll")); - - //parameters.ReferencedAssemblies.Add("OpenSim.Region.Environment"); - parameters.GenerateExecutable = false; - parameters.OutputAssembly = OutFile; - parameters.IncludeDebugInformation = CompileWithDebugInformation; - //parameters.WarningLevel = 1; // Should be 4? - parameters.TreatWarningsAsErrors = false; - -//Console.WriteLine(Script); - CompilerResults results; - switch (lang) - { - case enumCompileType.vb: - results = VBcodeProvider.CompileAssemblyFromSource(parameters, Script); - break; - case enumCompileType.cs: - results = CScodeProvider.CompileAssemblyFromSource(parameters, Script); - break; - case enumCompileType.js: - results = JScodeProvider.CompileAssemblyFromSource(parameters, Script); - break; - default: - throw new Exception("Compiler is not able to recongnize language type \"" + lang.ToString() + "\""); - } - - // Check result - // Go through errors - - // - // WARNINGS AND ERRORS - // - if (results.Errors.Count > 0) - { - string errtext = String.Empty; - foreach (CompilerError CompErr in results.Errors) - { - errtext += "Line number " + (CompErr.Line - LinesToRemoveOnError) + - ", Error Number: " + CompErr.ErrorNumber + - ", '" + CompErr.ErrorText + "'\r\n"; - } - if (!File.Exists(OutFile)) - { - throw new Exception(errtext); - } - } - - // - // NO ERRORS, BUT NO COMPILED FILE - // - if (!File.Exists(OutFile)) - { - string errtext = String.Empty; - errtext += "No compile error. But not able to locate compiled file."; - throw new Exception(errtext); - } - m_scriptEngine.Log.DebugFormat("[XEngine] Compiled new assembly for {0}", asset); - return OutFile; - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/EventManager.cs b/OpenSim/Region/ScriptEngine/XEngine/EventManager.cs index c226a7e..8bfef79 100644 --- a/OpenSim/Region/ScriptEngine/XEngine/EventManager.cs +++ b/OpenSim/Region/ScriptEngine/XEngine/EventManager.cs @@ -33,7 +33,8 @@ using OpenSim.Framework; using OpenSim.Region.Environment.Modules.Avatar.Currency.SampleMoney; using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Interfaces; -using OpenSim.Region.ScriptEngine.XEngine.Script; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.ScriptEngine.Interfaces; using Axiom.Math; namespace OpenSim.Region.ScriptEngine.XEngine @@ -83,8 +84,8 @@ namespace OpenSim.Region.ScriptEngine.XEngine IClientAPI remoteClient) { // Add to queue for all scripts in ObjectID object - XDetectParams[] det = new XDetectParams[1]; - det[0] = new XDetectParams(); + DetectParams[] det = new DetectParams[1]; + det[0] = new DetectParams(); det[0].Key = remoteClient.AgentId; det[0].Populate(myScriptEngine.World); @@ -97,7 +98,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine if (part.ParentGroup.Children.Count > 0) det[0].LinkNum = part.LinkNum + 1; - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "touch_start", new Object[] { new LSL_Types.LSLInteger(1) }, det)); } @@ -106,8 +107,8 @@ namespace OpenSim.Region.ScriptEngine.XEngine IClientAPI remoteClient) { // Add to queue for all scripts in ObjectID object - XDetectParams[] det = new XDetectParams[1]; - det[0] = new XDetectParams(); + DetectParams[] det = new DetectParams[1]; + det[0] = new DetectParams(); det[0].Key = remoteClient.AgentId; det[0].Populate(myScriptEngine.World); det[0].OffsetPos = new LSL_Types.Vector3(offsetPos.X, @@ -123,7 +124,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine if (part.ParentGroup.Children.Count > 0) det[0].LinkNum = part.LinkNum + 1; - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "touch", new Object[] { new LSL_Types.LSLInteger(1) }, det)); } @@ -131,8 +132,8 @@ namespace OpenSim.Region.ScriptEngine.XEngine public void touch_end(uint localID, IClientAPI remoteClient) { // Add to queue for all scripts in ObjectID object - XDetectParams[] det = new XDetectParams[1]; - det[0] = new XDetectParams(); + DetectParams[] det = new DetectParams[1]; + det[0] = new DetectParams(); det[0].Key = remoteClient.AgentId; det[0].Populate(myScriptEngine.World); @@ -145,7 +146,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine if (part.ParentGroup.Children.Count > 0) det[0].LinkNum = part.LinkNum + 1; - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "touch_end", new Object[] { new LSL_Types.LSLInteger(1) }, det)); } @@ -153,9 +154,9 @@ namespace OpenSim.Region.ScriptEngine.XEngine public void changed(uint localID, uint change) { // Add to queue for all scripts in localID, Object pass change. - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "changed",new object[] { new LSL_Types.LSLInteger(change) }, - new XDetectParams[0])); + new DetectParams[0])); } // state_entry: not processed here @@ -163,27 +164,27 @@ namespace OpenSim.Region.ScriptEngine.XEngine public void money(uint localID, LLUUID agentID, int amount) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "money", new object[] { new LSL_Types.LSLString(agentID.ToString()), new LSL_Types.LSLInteger(amount) }, - new XDetectParams[0])); + new DetectParams[0])); } public void collision_start(uint localID, ColliderArgs col) { // Add to queue for all scripts in ObjectID object - List det = new List(); + List det = new List(); foreach (DetectedObject detobj in col.Colliders) { - XDetectParams d = new XDetectParams(); + DetectParams d = new DetectParams(); d.Key =detobj.keyUUID; d.Populate(myScriptEngine.World); det.Add(d); } - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "collision_start", new Object[] { new LSL_Types.LSLInteger(1) }, det.ToArray())); @@ -192,17 +193,17 @@ namespace OpenSim.Region.ScriptEngine.XEngine public void collision(uint localID, ColliderArgs col) { // Add to queue for all scripts in ObjectID object - List det = new List(); + List det = new List(); foreach (DetectedObject detobj in col.Colliders) { - XDetectParams d = new XDetectParams(); + DetectParams d = new DetectParams(); d.Key =detobj.keyUUID; d.Populate(myScriptEngine.World); det.Add(d); } - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "collision", new Object[] { new LSL_Types.LSLInteger(1) }, det.ToArray())); } @@ -210,17 +211,17 @@ namespace OpenSim.Region.ScriptEngine.XEngine public void collision_end(uint localID, ColliderArgs col) { // Add to queue for all scripts in ObjectID object - List det = new List(); + List det = new List(); foreach (DetectedObject detobj in col.Colliders) { - XDetectParams d = new XDetectParams(); + DetectParams d = new DetectParams(); d.Key =detobj.keyUUID; d.Populate(myScriptEngine.World); det.Add(d); } - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "collision_end", new Object[] { new LSL_Types.LSLInteger(1) }, det.ToArray())); @@ -228,26 +229,26 @@ namespace OpenSim.Region.ScriptEngine.XEngine public void land_collision_start(uint localID, LLUUID itemID) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "land_collision_start", new object[0], - new XDetectParams[0])); + new DetectParams[0])); } public void land_collision(uint localID, LLUUID itemID) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "land_collision", new object[0], - new XDetectParams[0])); + new DetectParams[0])); } public void land_collision_end(uint localID, LLUUID itemID) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "land_collision_end", new object[0], - new XDetectParams[0])); + new DetectParams[0])); } // timer: not handled here @@ -255,75 +256,75 @@ namespace OpenSim.Region.ScriptEngine.XEngine public void on_rez(uint localID, LLUUID itemID, int startParam) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "on_rez",new object[] { new LSL_Types.LSLInteger(startParam)}, - new XDetectParams[0])); + new DetectParams[0])); } public void control(uint localID, LLUUID itemID, LLUUID agentID, uint held, uint change) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "control",new object[] { new LSL_Types.LSLString(agentID.ToString()), new LSL_Types.LSLInteger(held), new LSL_Types.LSLInteger(change)}, - new XDetectParams[0])); + new DetectParams[0])); } public void email(uint localID, LLUUID itemID, string timeSent, string address, string subject, string message, int numLeft) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "email",new object[] { new LSL_Types.LSLString(timeSent), new LSL_Types.LSLString(address), new LSL_Types.LSLString(subject), new LSL_Types.LSLString(message), new LSL_Types.LSLInteger(numLeft)}, - new XDetectParams[0])); + new DetectParams[0])); } public void at_target(uint localID, uint handle, LLVector3 targetpos, LLVector3 atpos) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "at_target", new object[] { new LSL_Types.LSLInteger(handle), new LSL_Types.Vector3(targetpos.X,targetpos.Y,targetpos.Z), new LSL_Types.Vector3(atpos.X,atpos.Y,atpos.Z) }, - new XDetectParams[0])); + new DetectParams[0])); } public void not_at_target(uint localID) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "not_at_target",new object[0], - new XDetectParams[0])); + new DetectParams[0])); } public void at_rot_target(uint localID, LLUUID itemID) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "at_rot_target",new object[0], - new XDetectParams[0])); + new DetectParams[0])); } public void not_at_rot_target(uint localID, LLUUID itemID) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "not_at_rot_target",new object[0], - new XDetectParams[0])); + new DetectParams[0])); } // run_time_permissions: not handled here public void attach(uint localID, LLUUID itemID, LLUUID avatar) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "attach",new object[] { new LSL_Types.LSLString(avatar.ToString()) }, - new XDetectParams[0])); + new DetectParams[0])); } // dataserver: not handled here @@ -331,16 +332,16 @@ namespace OpenSim.Region.ScriptEngine.XEngine public void moving_start(uint localID, LLUUID itemID) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "moving_start",new object[0], - new XDetectParams[0])); + new DetectParams[0])); } public void moving_end(uint localID, LLUUID itemID) { - myScriptEngine.PostObjectEvent(localID, new XEventParams( + myScriptEngine.PostObjectEvent(localID, new EventParams( "moving_end",new object[0], - new XDetectParams[0])); + new DetectParams[0])); } // object_rez: not handled here diff --git a/OpenSim/Region/ScriptEngine/XEngine/Executor.cs b/OpenSim/Region/ScriptEngine/XEngine/Executor.cs index 29336ac..e12f2bf 100644 --- a/OpenSim/Region/ScriptEngine/XEngine/Executor.cs +++ b/OpenSim/Region/ScriptEngine/XEngine/Executor.cs @@ -28,7 +28,8 @@ using System; using System.Collections.Generic; using System.Reflection; -using OpenSim.Region.ScriptEngine.XEngine.Script; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.ScriptEngine.Shared.ScriptBase; namespace OpenSim.Region.ScriptEngine.XEngine { @@ -44,15 +45,15 @@ namespace OpenSim.Region.ScriptEngine.XEngine } - protected override scriptEvents DoGetStateEventFlags() + protected override scriptEvents DoGetStateEventFlags(string state) { - //Console.WriteLine("Get event flags for " + m_Script.State); + //Console.WriteLine("Get event flags for " + state); // Check to see if we've already computed the flags for this state scriptEvents eventFlags = scriptEvents.None; - if (m_stateEvents.ContainsKey(m_Script.State)) + if (m_stateEvents.ContainsKey(state)) { - m_stateEvents.TryGetValue(m_Script.State, out eventFlags); + m_stateEvents.TryGetValue(state, out eventFlags); return eventFlags; } @@ -61,7 +62,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine // Fill in the events for this state, cache the results in the map foreach (KeyValuePair kvp in m_eventFlagsMap) { - string evname = m_Script.State + "_event_" + kvp.Key; + string evname = state + "_event_" + kvp.Key; //Console.WriteLine("Trying event "+evname); try { @@ -80,18 +81,18 @@ namespace OpenSim.Region.ScriptEngine.XEngine // Save the flags we just computed and return the result if (eventFlags != 0) - m_stateEvents.Add(m_Script.State, eventFlags); + m_stateEvents.Add(state, eventFlags); //Console.WriteLine("Returning {0:x}", eventFlags); return (eventFlags); } - protected override void DoExecuteEvent(string FunctionName, object[] args) + protected override void DoExecuteEvent(string state, string FunctionName, object[] args) { // IMPORTANT: Types and MemberInfo-derived objects require a LOT of memory. // Instead use RuntimeTypeHandle, RuntimeFieldHandle and RunTimeHandle (IntPtr) instead! - string EventName = m_Script.State + "_event_" + FunctionName; + string EventName = state + "_event_" + FunctionName; //#if DEBUG // Console.WriteLine("ScriptEngine: Script event function name: " + EventName); diff --git a/OpenSim/Region/ScriptEngine/XEngine/ExecutorBase.cs b/OpenSim/Region/ScriptEngine/XEngine/ExecutorBase.cs index 3775372..799005c 100644 --- a/OpenSim/Region/ScriptEngine/XEngine/ExecutorBase.cs +++ b/OpenSim/Region/ScriptEngine/XEngine/ExecutorBase.cs @@ -28,7 +28,9 @@ using System; using System.Collections.Generic; using System.Runtime.Remoting.Lifetime; -using OpenSim.Region.ScriptEngine.XEngine.Script; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.ScriptEngine.Shared.ScriptBase; +using OpenSim.Region.ScriptEngine.Interfaces; namespace OpenSim.Region.ScriptEngine.XEngine { @@ -117,23 +119,23 @@ namespace OpenSim.Region.ScriptEngine.XEngine /// /// Name of function to execute /// Arguments to pass to function - public void ExecuteEvent(string FunctionName, object[] args) + public void ExecuteEvent(string state, string FunctionName, object[] args) { - DoExecuteEvent(FunctionName, args); + DoExecuteEvent(state, FunctionName, args); } - protected abstract void DoExecuteEvent(string FunctionName, object[] args); + protected abstract void DoExecuteEvent(string state, string FunctionName, object[] args); /// /// Compute the events handled by the current state of the script /// /// state mask - public scriptEvents GetStateEventFlags() + public scriptEvents GetStateEventFlags(string state) { - return DoGetStateEventFlags(); + return DoGetStateEventFlags(state); } - protected abstract scriptEvents DoGetStateEventFlags(); + protected abstract scriptEvents DoGetStateEventFlags(string state); protected void initEventFlags() { diff --git a/OpenSim/Region/ScriptEngine/XEngine/LSL2CSConverter.cs b/OpenSim/Region/ScriptEngine/XEngine/LSL2CSConverter.cs deleted file mode 100644 index 2dc8547..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/LSL2CSConverter.cs +++ /dev/null @@ -1,374 +0,0 @@ -/* -* Copyright (c) Contributors, http://opensimulator.org/ -* See CONTRIBUTORS.TXT for a full list of copyright holders. -* -* Redistribution and use in source and binary forms, with or without -* modification, are permitted provided that the following conditions are met: -* * Redistributions of source code must retain the above copyright -* notice, this list of conditions and the following disclaimer. -* * Redistributions in binary form must reproduce the above copyright -* notice, this list of conditions and the following disclaimer in the -* documentation and/or other materials provided with the distribution. -* * Neither the name of the OpenSim Project nor the -* names of its contributors may be used to endorse or promote products -* derived from this software without specific prior written permission. -* -* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS AS IS AND ANY -* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY -* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -* -*/ - -using System; -using System.Collections.Generic; -using System.Text.RegularExpressions; - -namespace OpenSim.Region.ScriptEngine.XEngine -{ - public class LSL2CSConverter - { - // Uses regex to convert LSL code to C# code. - - //private Regex rnw = new Regex(@"[a-zA-Z0-9_\-]", RegexOptions.Compiled); - private Dictionary dataTypes = new Dictionary(); - private Dictionary quotes = new Dictionary(); - // c Style - private Regex cstylecomments = new Regex(@"/\*(.|[\r\n])*?\*/", RegexOptions.Compiled | RegexOptions.Multiline); - // c# one liners - private Regex nonCommentFwsl = new Regex("\"[a-zA-Z0-9.,:/\\n ]+//[^\"+]+([\\\\\\\"+]+)?(\\s+)?[\"+](\\s+)?(;)?", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - private Regex conelinecomments = new Regex(@"[^:].?([\/]{2}[^\n]*)|([\n]{1,}[\/]{2}[^\n]*)", RegexOptions.Compiled | RegexOptions.Multiline); - // ([^\"])((?:[a-zA-Z])\.[a-zA-Z].?)([^\"]) - - // value we're looking for: (?:[a-zA-Z])\.[a-zA-Z] - public LSL2CSConverter() - { - // Only the types we need to convert - dataTypes.Add("void", "void"); - dataTypes.Add("integer", "LSL_Types.LSLInteger"); - dataTypes.Add("float", "LSL_Types.LSLFloat"); - dataTypes.Add("string", "LSL_Types.LSLString"); - dataTypes.Add("key", "LSL_Types.LSLString"); - dataTypes.Add("vector", "LSL_Types.Vector3"); - dataTypes.Add("rotation", "LSL_Types.Quaternion"); - dataTypes.Add("list", "LSL_Types.list"); - dataTypes.Add("null", "null"); - } - - public string Convert(string Script) - { - quotes.Clear(); - string Return = String.Empty; - Script = " \r\n" + Script; - - // - // Prepare script for processing - // - - // Clean up linebreaks - Script = Regex.Replace(Script, @"\r\n", "\n"); - Script = Regex.Replace(Script, @"\n", "\r\n"); - - // QUOTE REPLACEMENT - // temporarily replace quotes so we can work our magic on the script without - // always considering if we are inside our outside quotes's - // TODO: Does this work on half-quotes in strings? ;) - string _Script = String.Empty; - string C; - bool in_quote = false; - bool quote_replaced = false; - string quote_replacement_string = "Q_U_O_T_E_REPLACEMENT_"; - string quote = String.Empty; - bool last_was_escape = false; - int quote_replaced_count = 0; - - string removefwnoncomments = nonCommentFwsl.Replace(Script, "\"\";"); - - string removecomments = conelinecomments.Replace(removefwnoncomments, ""); - removecomments = cstylecomments.Replace(removecomments, ""); - string[] localscript = removecomments.Split('"'); - string checkscript = String.Empty; - bool flip = true; - - for (int p = 0; p < localscript.Length; p++) - { - //if (localscript[p].Length >= 1) - //{ - if (!localscript[p].EndsWith(@"\")) - { - flip = !flip; - //System.Console.WriteLine("Flip:" + flip.ToString() + " - " + localscript[p] + " ! " + localscript[p].EndsWith(@"\").ToString()); - } - //} - //else - //{ - // flip = !flip; - // System.Console.WriteLine("Flip:" + flip.ToString() + " - " + localscript[p]); - //} - if (!flip) - checkscript += localscript[p]; - } - - //System.Console.WriteLine("SCRIPT:" + checkscript); - - // checks for alpha.alpha way of referring to objects in C# - // ignores alpha.x alpha.y, alpha.z for refering to vector components - Match SecurityM; - - // BROKEN: this check is very wrong. It block's any url in strings. - SecurityM = Regex.Match(checkscript, @"(?:[a-zA-Z])\.(?:[a-wA-Z]|[a-zA-Z][a-zA-Z])", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - - if (SecurityM.Success) - throw new Exception("CS0103: 'The . symbol cannot be used in LSL except in float values or vector components'. Detected around: " + SecurityM.Captures[0].Value); - - SecurityM = Regex.Match(checkscript, @"typeof\s", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - if (SecurityM.Success) - throw new Exception("CS0103: 'The object.typeof method isn't allowed in LSL'"); - - SecurityM = Regex.Match(checkscript, @"GetType\(", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - if (SecurityM.Success) - throw new Exception("CS0103: 'The object.GetType method isn't allowed in LSL'"); - - for (int p = 0; p < Script.Length; p++) - { - C = Script.Substring(p, 1); - while (true) - { - // found " and last was not \ so this is not an escaped \" - if (C == "\"" && last_was_escape == false) - { - // Toggle inside/outside quote - in_quote = !in_quote; - if (in_quote) - { - quote_replaced_count++; - } - else - { - if (quote == String.Empty) - { - // We didn't replace quote, probably because of empty string? - _Script += quote_replacement_string + - quote_replaced_count.ToString().PadLeft(5, "0".ToCharArray()[0]); - } - // We just left a quote - quotes.Add( - quote_replacement_string + - quote_replaced_count.ToString().PadLeft(5, "0".ToCharArray()[0]), quote); - quote = String.Empty; - } - break; - } - - if (!in_quote) - { - // We are not inside a quote - quote_replaced = false; - } - else - { - // We are inside a quote - if (!quote_replaced) - { - // Replace quote - _Script += quote_replacement_string + - quote_replaced_count.ToString().PadLeft(5, "0".ToCharArray()[0]); - quote_replaced = true; - } - quote += C; - break; - } - _Script += C; - break; - } - last_was_escape = false; - if (C == @"\") - { - last_was_escape = true; - } - } - Script = _Script; - // - // END OF QUOTE REPLACEMENT - // - - // - // PROCESS STATES - // Remove state definitions and add state names to start of each event within state - // - int ilevel = 0; - int lastlevel = 0; - string ret = String.Empty; - string cache = String.Empty; - bool in_state = false; - string current_statename = String.Empty; - for (int p = 0; p < Script.Length; p++) - { - C = Script.Substring(p, 1); - while (true) - { - // inc / dec level - if (C == @"{") - ilevel++; - if (C == @"}") - ilevel--; - if (ilevel < 0) - ilevel = 0; - cache += C; - - // if level == 0, add to return - if (ilevel == 1 && lastlevel == 0) - { - // 0 => 1: Get last - Match m = - //Regex.Match(cache, @"(?![a-zA-Z_]+)\s*([a-zA-Z_]+)[^a-zA-Z_\(\)]*{", - Regex.Match(cache, @"(?![a-zA-Z_]+)\s*(state\s+)?(?[a-zA-Z_][a-zA-Z_0-9]*)[^a-zA-Z_0-9\(\)]*{", - - RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - - in_state = false; - if (m.Success) - { - // Go back to level 0, this is not a state - in_state = true; - current_statename = m.Groups["statename"].Captures[0].Value; - //Console.WriteLine("Current statename: " + current_statename); - cache = - //@"(?(?![a-zA-Z_]+)\s*)" + @"([a-zA-Z_]+)(?[^a-zA-Z_\(\)]*){", - Regex.Replace(cache, - @"(?(?![a-zA-Z_]+)\s*)" + @"(state\s+)?([a-zA-Z_][a-zA-Z_0-9]*)(?[^a-zA-Z_0-9\(\)]*){", - "${s1}${s2}", - RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase); - } - ret += cache; - cache = String.Empty; - } - if (ilevel == 0 && lastlevel == 1) - { - // 1 => 0: Remove last } - if (in_state == true) - { - cache = cache.Remove(cache.Length - 1, 1); - //cache = Regex.Replace(cache, "}$", String.Empty, RegexOptions.Multiline | RegexOptions.Singleline); - - //Replace function names - // void dataserver(key query_id, string data) { - //cache = Regex.Replace(cache, @"([^a-zA-Z_]\s*)((?!if|switch|for)[a-zA-Z_]+\s*\([^\)]*\)[^{]*{)", "$1" + "" + "$2", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - //Console.WriteLine("Replacing using statename: " + current_statename); - cache = - Regex.Replace(cache, - @"^(\s*)((?!(if|switch|for|while)[^a-zA-Z0-9_])[a-zA-Z0-9_]*\s*\([^\)]*\)[^;]*\{)", - @"$1public " + current_statename + "_event_$2", - RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase); - } - - ret += cache; - cache = String.Empty; - in_state = true; - current_statename = String.Empty; - } - - break; - } - lastlevel = ilevel; - } - ret += cache; - cache = String.Empty; - - Script = ret; - ret = String.Empty; - - foreach (string key in dataTypes.Keys) - { - string val; - dataTypes.TryGetValue(key, out val); - - // Replace CAST - (integer) with (int) - Script = - Regex.Replace(Script, @"\(" + key + @"\)", @"(" + val + ")", - RegexOptions.Compiled | RegexOptions.Multiline); - // Replace return types and function variables - integer a() and f(integer a, integer a) - Script = - Regex.Replace(Script, @"(^|;|}|[\(,])(\s*)" + key + @"(\s+)", @"$1$2" + val + "$3", - RegexOptions.Compiled | RegexOptions.Multiline); - Script = - Regex.Replace(Script, @"(^|;|}|[\(,])(\s*)" + key + @"(\s*)[,]", @"$1$2" + val + "$3,", - RegexOptions.Compiled | RegexOptions.Multiline); - } - - // Change jumps into goto's and prefix its label - Script = - Regex.Replace(Script, - @"(\W)jump\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*;", - @"$1goto label_$2;", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - // and prefix labels so the do not clash with C#'s reserved words - Script = - Regex.Replace(Script, - @"@([a-zA-Z_][a-zA-Z_0-9]*)\s*;", - @"label_$1: ;", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - - // Add "void" in front of functions that needs it - Script = - Regex.Replace(Script, - @"^(\s*public\s+)?((?!(if|switch|for)[^a-zA-Z0-9_])[a-zA-Z0-9_]*\s*\([^\)]*\)[^;]*\{)", - @"$1void $2", RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - - // Replace and - Script = - Regex.Replace(Script, @"<([^,>;]*,[^,>;]*,[^,>;]*,[^,>;]*)>", @"new LSL_Types.Quaternion($1)", - RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - Script = - Regex.Replace(Script, @"<([^,>;)]*,[^,>;]*,[^,>;]*)>", @"new LSL_Types.Vector3($1)", - RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - - // Replace List []'s - Script = - Regex.Replace(Script, @"\[([^\]]*)\]", @"new LSL_Types.list($1)", - RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - - // Replace (string) to .ToString() // - Script = - Regex.Replace(Script, @"\(string\)\s*([a-zA-Z0-9_.]+(\s*\([^\)]*\))?)", @"$1.ToString()", - RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - Script = - Regex.Replace(Script, @"\((float|int)\)\s*([a-zA-Z0-9_.]+(\s*\([^\)]*\))?)", @"$1.Parse($2)", - RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline); - - // Replace "state STATENAME" with "state("statename")" - Script = - Regex.Replace(Script, @"(state)\s+([^;\n\r]+)(;[\r\n\s])", "$1(\"$2\")$3", - RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase); - - // REPLACE BACK QUOTES - foreach (string key in quotes.Keys) - { - string val; - quotes.TryGetValue(key, out val); - Script = Script.Replace(key, "\"" + val + "\""); - } - - //System.Console.WriteLine(Script); - Return = String.Empty;// + - //"using OpenSim.Region.ScriptEngine.Common; using System.Collections.Generic;"; - - //Return += String.Empty + - // "namespace SecondLife { "; - //Return += String.Empty + - // //"[Serializable] " + - // "public class Script : OpenSim.Region.ScriptEngine.Common.LSL_BaseClass { "; - //Return += @"public Script() { } "; - Return += Script; - //Return += "} }\r\n"; - - quotes.Clear(); - - return Return; - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/LSL_ScriptCommands.cs b/OpenSim/Region/ScriptEngine/XEngine/LSL_ScriptCommands.cs deleted file mode 100644 index 9c660c1..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/LSL_ScriptCommands.cs +++ /dev/null @@ -1,6593 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using System.Collections; -using System.Collections.Generic; -using System.Runtime.Remoting.Lifetime; -using System.Text; -using System.Threading; -using Nini.Config; -using Axiom.Math; -using libsecondlife; -using OpenSim; -using OpenSim.Framework; -using OpenSim.Region.Environment; -using OpenSim.Region.Environment.Interfaces; -using OpenSim.Region.Environment.Modules.Avatar.Currency.SampleMoney; -using OpenSim.Region.Environment.Modules.World.Land; -using OpenSim.Region.Environment.Scenes; -using OpenSim.Region.ScriptEngine.XEngine; -using OpenSim.Region.ScriptEngine.XEngine.Script; - - -namespace OpenSim.Region.ScriptEngine.XEngine -{ - /// - /// Contains all LSL ll-functions. This class will be in Default AppDomain. - /// - public class LSL_ScriptCommands : MarshalByRefObject, ILSL_ScriptCommands - { - // private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); - - internal XEngine m_ScriptEngine; - internal XScriptInstance m_Instance; - internal SceneObjectPart m_host; - internal uint m_localID; - internal LLUUID m_itemID; - internal bool throwErrorOnNotImplemented = true; - - public LSL_ScriptCommands(XEngine ScriptEngine, XScriptInstance instance, SceneObjectPart host, uint localID, LLUUID itemID) - { - m_ScriptEngine = ScriptEngine; - m_Instance = instance; - m_host = host; - m_localID = localID; - m_itemID = itemID; - - //m_log.Info(ScriptEngineName, "LSL_BaseClass.Start() called. Hosted by [" + m_host.Name + ":" + m_host.UUID + "@" + m_host.AbsolutePosition + "]"); - } - - private DateTime m_timer = DateTime.Now; - private string m_state = "default"; - private bool m_waitingForScriptAnswer=false; - - - public string State - { - get { return m_Instance.State; } - set { m_Instance.State = value; } - } - - public void state(string newState) - { - m_Instance.SetState(newState); - } - - // Object never expires - public override Object InitializeLifetimeService() - { - //Console.WriteLine("LSL_BuiltIn_Commands: InitializeLifetimeService()"); - // return null; - ILease lease = (ILease)base.InitializeLifetimeService(); - - if (lease.CurrentState == LeaseState.Initial) - { - lease.InitialLeaseTime = TimeSpan.Zero; // TimeSpan.FromMinutes(1); - // lease.SponsorshipTimeout = TimeSpan.FromMinutes(2); - // lease.RenewOnCallTime = TimeSpan.FromSeconds(2); - } - return lease; - } - - public Scene World - { - get { return m_ScriptEngine.World; } - } - - public void llSay(int channelID, string text) - { - m_host.AddScriptLPS(1); - - if (text.Length > 1023) - text = text.Substring(0, 1023); - - World.SimChat(Helpers.StringToField(text), - ChatTypeEnum.Say, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false); - - IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); - wComm.DeliverMessage(ChatTypeEnum.Say, channelID, m_host.Name, m_host.UUID, text); - } - - // Extension commands use this: - public ICommander GetCommander(string name) - { - return World.GetCommander(name); - } - - private LLUUID InventorySelf() - { - LLUUID invItemID = new LLUUID(); - - foreach (KeyValuePair inv in m_host.TaskInventory) - { - if (inv.Value.Type == 10 && inv.Value.ItemID == m_itemID) - { - invItemID = inv.Key; - break; - } - } - - return invItemID; - } - - private LLUUID InventoryKey(string name, int type) - { - m_host.AddScriptLPS(1); - foreach (KeyValuePair inv in m_host.TaskInventory) - { - if (inv.Value.Name == name) - { - if (inv.Value.Type != type) - return LLUUID.Zero; - - return inv.Value.AssetID.ToString(); - } - } - return LLUUID.Zero; - } - - private LLUUID InventoryKey(string name) - { - m_host.AddScriptLPS(1); - foreach (KeyValuePair inv in m_host.TaskInventory) - { - if (inv.Value.Name == name) - { - return inv.Value.AssetID.ToString(); - } - } - return LLUUID.Zero; - } - - - /// - /// accepts a valid LLUUID, -or- a name of an inventory item. - /// Returns a valid LLUUID or LLUUID.Zero if key invalid and item not found - /// in prim inventory. - /// - /// - /// - private LLUUID KeyOrName(string k) - { - LLUUID key = LLUUID.Zero; - - // if we can parse the string as a key, use it. - if (LLUUID.TryParse(k, out key)) - { - return key; - } - // else try to locate the name in inventory of object. found returns key, - // not found returns LLUUID.Zero which will translate to the default particle texture - else - { - return InventoryKey(k); - } - } - - public void osSetRegionWaterHeight(double height) - { - m_host.AddScriptLPS(1); - //Check to make sure that the script's owner is the estate manager/master - //World.Permissions.GenericEstatePermission( - if (World.ExternalChecks.ExternalChecksCanBeGodLike(m_host.OwnerID)) - { - World.EventManager.TriggerRequestChangeWaterHeight((float)height); - } - } - - //These are the implementations of the various ll-functions used by the LSL scripts. - //starting out, we use the System.Math library for trig functions. - ckrinke 8-14-07 - public double llSin(double f) - { - m_host.AddScriptLPS(1); - return (double)Math.Sin(f); - } - - public double llCos(double f) - { - m_host.AddScriptLPS(1); - return (double)Math.Cos(f); - } - - public double llTan(double f) - { - m_host.AddScriptLPS(1); - return (double)Math.Tan(f); - } - - public double llAtan2(double x, double y) - { - m_host.AddScriptLPS(1); - return (double)Math.Atan2(y, x); - } - - public double llSqrt(double f) - { - m_host.AddScriptLPS(1); - return (double)Math.Sqrt(f); - } - - public double llPow(double fbase, double fexponent) - { - m_host.AddScriptLPS(1); - return (double)Math.Pow(fbase, fexponent); - } - - public LSL_Types.LSLInteger llAbs(int i) - { - m_host.AddScriptLPS(1); - return (int)Math.Abs(i); - } - - public double llFabs(double f) - { - m_host.AddScriptLPS(1); - return (double)Math.Abs(f); - } - - public double llFrand(double mag) - { - m_host.AddScriptLPS(1); - lock (Util.RandomClass) - { - return Util.RandomClass.NextDouble() * mag; - } - } - - public LSL_Types.LSLInteger llFloor(double f) - { - m_host.AddScriptLPS(1); - return (int)Math.Floor(f); - } - - public LSL_Types.LSLInteger llCeil(double f) - { - m_host.AddScriptLPS(1); - return (int)Math.Ceiling(f); - } - - // Xantor 01/May/2008 fixed midpointrounding (2.5 becomes 3.0 instead of 2.0, default = ToEven) - public LSL_Types.LSLInteger llRound(double f) - { - m_host.AddScriptLPS(1); - return (int)Math.Round(f, MidpointRounding.AwayFromZero); - } - - //This next group are vector operations involving squaring and square root. ckrinke - public double llVecMag(LSL_Types.Vector3 v) - { - m_host.AddScriptLPS(1); - return LSL_Types.Vector3.Mag(v); - } - - public LSL_Types.Vector3 llVecNorm(LSL_Types.Vector3 v) - { - m_host.AddScriptLPS(1); - double mag = LSL_Types.Vector3.Mag(v); - LSL_Types.Vector3 nor = new LSL_Types.Vector3(); - nor.x = v.x / mag; - nor.y = v.y / mag; - nor.z = v.z / mag; - return nor; - } - - public double llVecDist(LSL_Types.Vector3 a, LSL_Types.Vector3 b) - { - m_host.AddScriptLPS(1); - double dx = a.x - b.x; - double dy = a.y - b.y; - double dz = a.z - b.z; - return Math.Sqrt(dx * dx + dy * dy + dz * dz); - } - - //Now we start getting into quaternions which means sin/cos, matrices and vectors. ckrinke - - // Utility function for llRot2Euler - - // normalize an angle between 0 - 2*PI (0 and 360 degrees) - private double NormalizeAngle(double angle) - { - angle = angle % (Math.PI * 2); - if (angle < 0) angle = angle + Math.PI * 2; - return angle; - } - - // Old implementation of llRot2Euler, now normalized - - public LSL_Types.Vector3 llRot2Euler(LSL_Types.Quaternion r) - { - m_host.AddScriptLPS(1); - //This implementation is from http://lslwiki.net/lslwiki/wakka.php?wakka=LibraryRotationFunctions. ckrinke - LSL_Types.Quaternion t = new LSL_Types.Quaternion(r.x * r.x, r.y * r.y, r.z * r.z, r.s * r.s); - double m = (t.x + t.y + t.z + t.s); - if (m == 0) return new LSL_Types.Vector3(); - double n = 2 * (r.y * r.s + r.x * r.z); - double p = m * m - n * n; - if (p > 0) - return new LSL_Types.Vector3(NormalizeAngle(Math.Atan2(2.0 * (r.x * r.s - r.y * r.z), (-t.x - t.y + t.z + t.s))), - NormalizeAngle(Math.Atan2(n, Math.Sqrt(p))), - NormalizeAngle(Math.Atan2(2.0 * (r.z * r.s - r.x * r.y), (t.x - t.y - t.z + t.s)))); - else if (n > 0) - return new LSL_Types.Vector3(0.0, Math.PI / 2, NormalizeAngle(Math.Atan2((r.z * r.s + r.x * r.y), 0.5 - t.x - t.z))); - else - return new LSL_Types.Vector3(0.0, -Math.PI / 2, NormalizeAngle(Math.Atan2((r.z * r.s + r.x * r.y), 0.5 - t.x - t.z))); - } - - // Xantor's newer llEuler2Rot() *try the second* inverted quaternions (-x,-y,-z,w) as LL seems to like - // New and improved, now actually works as described. Prim rotates as expected as does llRot2Euler. - - /* From wiki: - The Euler angle vector (in radians) is converted to a rotation by doing the rotations around the 3 axes - in Z, Y, X order. So llEuler2Rot(<1.0, 2.0, 3.0> * DEG_TO_RAD) generates a rotation by taking the zero rotation, - a vector pointing along the X axis, first rotating it 3 degrees around the global Z axis, then rotating the resulting - vector 2 degrees around the global Y axis, and finally rotating that 1 degree around the global X axis. - */ - - public LSL_Types.Quaternion llEuler2Rot(LSL_Types.Vector3 v) - { - m_host.AddScriptLPS(1); - - double x,y,z,s,s_i; - - double cosX = Math.Cos(v.x); - double cosY = Math.Cos(v.y); - double cosZ = Math.Cos(v.z); - double sinX = Math.Sin(v.x); - double sinY = Math.Sin(v.y); - double sinZ = Math.Sin(v.z); - - s = Math.Sqrt(cosY * cosZ - sinX * sinY * sinZ + cosX * cosZ + cosX * cosY + 1.0f) * 0.5f; - if (Math.Abs(s) < 0.00001) // null rotation - { - x = 0.0f; - y = 1.0f; - z = 0.0f; - } - else - { - s_i = 1.0f / (4.0f * s); - x = - (-sinX * cosY - cosX * sinY * sinZ - sinX * cosZ) * s_i; - y = - (-cosX * sinY * cosZ + sinX * sinZ - sinY) * s_i; - z = - (-cosY * sinZ - sinX * sinY * cosZ - cosX * sinZ) * s_i; - } - return new LSL_Types.Quaternion(x, y, z, s); - } - - public LSL_Types.Quaternion llAxes2Rot(LSL_Types.Vector3 fwd, LSL_Types.Vector3 left, LSL_Types.Vector3 up) - { - m_host.AddScriptLPS(1); - NotImplemented("llAxes2Rot"); - return new LSL_Types.Quaternion(); - } - - public LSL_Types.Vector3 llRot2Fwd(LSL_Types.Quaternion r) - { - m_host.AddScriptLPS(1); - return (new LSL_Types.Vector3(1,0,0) * r); - } - - public LSL_Types.Vector3 llRot2Left(LSL_Types.Quaternion r) - { - m_host.AddScriptLPS(1); - return (new LSL_Types.Vector3(0, 1, 0) * r); - } - - public LSL_Types.Vector3 llRot2Up(LSL_Types.Quaternion r) - { - m_host.AddScriptLPS(1); - return (new LSL_Types.Vector3(0, 0, 1) * r); - } - - public LSL_Types.Quaternion llRotBetween(LSL_Types.Vector3 a, LSL_Types.Vector3 b) - { - //A and B should both be normalized - m_host.AddScriptLPS(1); - double dotProduct = LSL_Types.Vector3.Dot(a, b); - LSL_Types.Vector3 crossProduct = LSL_Types.Vector3.Cross(a, b); - double magProduct = LSL_Types.Vector3.Mag(a) * LSL_Types.Vector3.Mag(b); - double angle = Math.Acos(dotProduct / magProduct); - LSL_Types.Vector3 axis = LSL_Types.Vector3.Norm(crossProduct); - double s = Math.Sin(angle / 2); - - return new LSL_Types.Quaternion(axis.x * s, axis.y * s, axis.z * s, (float)Math.Cos(angle / 2)); - } - - public void llWhisper(int channelID, string text) - { - m_host.AddScriptLPS(1); - - if (text.Length > 1023) - text = text.Substring(0, 1023); - - World.SimChat(Helpers.StringToField(text), - ChatTypeEnum.Whisper, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false); - - IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); - wComm.DeliverMessage(ChatTypeEnum.Whisper, channelID, m_host.Name, m_host.UUID, text); - } - - public void llShout(int channelID, string text) - { - m_host.AddScriptLPS(1); - - if (text.Length > 1023) - text = text.Substring(0, 1023); - - World.SimChat(Helpers.StringToField(text), - ChatTypeEnum.Shout, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID, true); - - IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); - wComm.DeliverMessage(ChatTypeEnum.Shout, channelID, m_host.Name, m_host.UUID, text); - } - - public void llRegionSay(int channelID, string text) - { - if (channelID == 0) - { - LSLError("Cannot use llRegionSay() on channel 0"); - return; - } - - if (text.Length > 1023) - text = text.Substring(0, 1023); - - m_host.AddScriptLPS(1); - - IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); - wComm.DeliverMessage(ChatTypeEnum.Region, channelID, m_host.Name, m_host.UUID, text); - } - - public LSL_Types.LSLInteger llListen(int channelID, string name, string ID, string msg) - { - m_host.AddScriptLPS(1); - LLUUID keyID; - LLUUID.TryParse(ID, out keyID); - IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); - return wComm.Listen(m_localID, m_itemID, m_host.UUID, channelID, name, keyID, msg); - } - - public void llListenControl(int number, int active) - { - m_host.AddScriptLPS(1); - IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); - wComm.ListenControl(m_itemID, number, active); - } - - public void llListenRemove(int number) - { - m_host.AddScriptLPS(1); - IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); - wComm.ListenRemove(m_itemID, number); - } - - public void llSensor(string name, string id, int type, double range, double arc) - { - m_host.AddScriptLPS(1); - LLUUID keyID = LLUUID.Zero; - LLUUID.TryParse(id, out keyID); - - m_ScriptEngine.m_ASYNCLSLCommandManager.m_SensorRepeat.SenseOnce(m_localID, m_itemID, name, keyID, type, range, arc, m_host); - } - - public void llSensorRepeat(string name, string id, int type, double range, double arc, double rate) - { - m_host.AddScriptLPS(1); - LLUUID keyID = LLUUID.Zero; - LLUUID.TryParse(id, out keyID); - - m_ScriptEngine.m_ASYNCLSLCommandManager.m_SensorRepeat.SetSenseRepeatEvent(m_localID, m_itemID, name, keyID, type, range, arc, rate, m_host); - } - - public void llSensorRemove() - { - m_host.AddScriptLPS(1); - m_ScriptEngine.m_ASYNCLSLCommandManager.m_SensorRepeat.UnSetSenseRepeaterEvents(m_localID, m_itemID); - } - - public string resolveName(LLUUID objecUUID) - { - // try avatar username surname - UserProfileData profile = World.CommsManager.UserService.GetUserProfile(objecUUID); - if (profile != null) - { - string avatarname = profile.FirstName + " " + profile.SurName; - return avatarname; - } - // try an scene object - SceneObjectPart SOP = World.GetSceneObjectPart(objecUUID); - if (SOP != null) - { - string objectname = SOP.Name; - return objectname; - } - - EntityBase SensedObject; - lock (World.Entities) - { - World.Entities.TryGetValue(objecUUID, out SensedObject); - } - - if (SensedObject == null) - return String.Empty; - return SensedObject.Name; - } - - public string llDetectedName(int number) - { - m_host.AddScriptLPS(1); - XDetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); - if (d == null) - return String.Empty; - return d.Name; - } - - public string llDetectedKey(int number) - { - m_host.AddScriptLPS(1); - XDetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); - if (d == null) - return String.Empty; - return d.Key.ToString(); - } - - public string llDetectedOwner(int number) - { - m_host.AddScriptLPS(1); - XDetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); - if (d == null) - return String.Empty; - return d.Owner.ToString(); - } - - public LSL_Types.LSLInteger llDetectedType(int number) - { - m_host.AddScriptLPS(1); - XDetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); - if (d == null) - return 0; - return new LSL_Types.LSLInteger(d.Type); - } - - public LSL_Types.Vector3 llDetectedPos(int number) - { - m_host.AddScriptLPS(1); - XDetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); - if (d == null) - return new LSL_Types.Vector3(); - return d.Position; - } - - public LSL_Types.Vector3 llDetectedVel(int number) - { - m_host.AddScriptLPS(1); - XDetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); - if (d == null) - return new LSL_Types.Vector3(); - return d.Velocity; - } - - public LSL_Types.Vector3 llDetectedGrab(int number) - { - m_host.AddScriptLPS(1); - XDetectParams parms = m_ScriptEngine.GetDetectParams(m_itemID, number); - if (parms == null) - return new LSL_Types.Vector3(0, 0, 0); - - return parms.OffsetPos; - } - - public LSL_Types.Quaternion llDetectedRot(int number) - { - m_host.AddScriptLPS(1); - XDetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); - if (d == null) - return new LSL_Types.Quaternion(); - return d.Rotation; - } - - public LSL_Types.LSLInteger llDetectedGroup(int number) - { - m_host.AddScriptLPS(1); - XDetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number); - if (d == null) - return new LSL_Types.LSLInteger(0); - if (m_host.GroupID == d.Group) - return new LSL_Types.LSLInteger(1); - return new LSL_Types.LSLInteger(0); - } - - public LSL_Types.LSLInteger llDetectedLinkNumber(int number) - { - m_host.AddScriptLPS(1); - XDetectParams parms = m_ScriptEngine.GetDetectParams(m_itemID, number); - if (parms == null) - return new LSL_Types.LSLInteger(0); - - return new LSL_Types.LSLInteger(parms.LinkNum); - } - - public void llDie() - { - m_host.AddScriptLPS(1); - World.DeleteSceneObject(m_host.ParentGroup); - } - - public double llGround(LSL_Types.Vector3 offset) - { - m_host.AddScriptLPS(1); - int x = (int)(m_host.AbsolutePosition.X + offset.x); - int y = (int)(m_host.AbsolutePosition.Y + offset.y); - return World.GetLandHeight(x, y); - } - - public double llCloud(LSL_Types.Vector3 offset) - { - m_host.AddScriptLPS(1); - NotImplemented("llCloud"); - return 0; - } - - public LSL_Types.Vector3 llWind(LSL_Types.Vector3 offset) - { - m_host.AddScriptLPS(1); - NotImplemented("llWind"); - return new LSL_Types.Vector3(); - } - - public void llSetStatus(int status, int value) - { - m_host.AddScriptLPS(1); - - int statusrotationaxis = 0; - - if ((status & BuiltIn_Commands_BaseClass.STATUS_PHYSICS) == BuiltIn_Commands_BaseClass.STATUS_PHYSICS) - { - if (value == 1) - m_host.ScriptSetPhysicsStatus(true); - else - m_host.ScriptSetPhysicsStatus(false); - } - - if ((status & BuiltIn_Commands_BaseClass.STATUS_PHANTOM) == BuiltIn_Commands_BaseClass.STATUS_PHANTOM) - { - if (value == 1) - m_host.ScriptSetPhantomStatus(true); - else - m_host.ScriptSetPhantomStatus(false); - } - - if ((status & BuiltIn_Commands_BaseClass.STATUS_CAST_SHADOWS) == BuiltIn_Commands_BaseClass.STATUS_CAST_SHADOWS) - { - m_host.AddFlag(LLObject.ObjectFlags.CastShadows); - } - - if ((status & BuiltIn_Commands_BaseClass.STATUS_ROTATE_X) == BuiltIn_Commands_BaseClass.STATUS_ROTATE_X) - { - statusrotationaxis |= BuiltIn_Commands_BaseClass.STATUS_ROTATE_X; - } - - if ((status & BuiltIn_Commands_BaseClass.STATUS_ROTATE_Y) == BuiltIn_Commands_BaseClass.STATUS_ROTATE_Y) - { - statusrotationaxis |= BuiltIn_Commands_BaseClass.STATUS_ROTATE_Y; - } - - if ((status & BuiltIn_Commands_BaseClass.STATUS_ROTATE_Z) == BuiltIn_Commands_BaseClass.STATUS_ROTATE_Z) - { - statusrotationaxis |= BuiltIn_Commands_BaseClass.STATUS_ROTATE_Z; - } - - if ((status & BuiltIn_Commands_BaseClass.STATUS_BLOCK_GRAB) == BuiltIn_Commands_BaseClass.STATUS_BLOCK_GRAB) - { - NotImplemented("llSetStatus - STATUS_BLOCK_GRAB"); - } - - if ((status & BuiltIn_Commands_BaseClass.STATUS_DIE_AT_EDGE) == BuiltIn_Commands_BaseClass.STATUS_DIE_AT_EDGE) - { - if (value == 1) - m_host.SetDieAtEdge(true); - else - m_host.SetDieAtEdge(false); - } - - if ((status & BuiltIn_Commands_BaseClass.STATUS_RETURN_AT_EDGE) == BuiltIn_Commands_BaseClass.STATUS_RETURN_AT_EDGE) - { - NotImplemented("llSetStatus - STATUS_RETURN_AT_EDGE"); - } - - if ((status & BuiltIn_Commands_BaseClass.STATUS_SANDBOX) == BuiltIn_Commands_BaseClass.STATUS_SANDBOX) - { - NotImplemented("llSetStatus - STATUS_SANDBOX"); - } - - if (statusrotationaxis != 0) - { - m_host.SetAxisRotation(statusrotationaxis, value); - } - } - - public LSL_Types.LSLInteger llGetStatus(int status) - { - m_host.AddScriptLPS(1); - // Console.WriteLine(m_host.UUID.ToString() + " status is " + m_host.GetEffectiveObjectFlags().ToString()); - switch (status) - { - case BuiltIn_Commands_BaseClass.STATUS_PHYSICS: - if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Physics) == (uint)LLObject.ObjectFlags.Physics) - { - return 1; - } - return 0; - - case BuiltIn_Commands_BaseClass.STATUS_PHANTOM: - if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Phantom) == (uint)LLObject.ObjectFlags.Phantom) - { - return 1; - } - return 0; - - case BuiltIn_Commands_BaseClass.STATUS_CAST_SHADOWS: - if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.CastShadows) == (uint)LLObject.ObjectFlags.CastShadows) - { - return 1; - } - return 0; - - case BuiltIn_Commands_BaseClass.STATUS_BLOCK_GRAB: - NotImplemented("llGetStatus - STATUS_BLOCK_GRAB"); - return 0; - - case BuiltIn_Commands_BaseClass.STATUS_DIE_AT_EDGE: - if (m_host.GetDieAtEdge()) - return 1; - else - return 0; - - case BuiltIn_Commands_BaseClass.STATUS_RETURN_AT_EDGE: - NotImplemented("llGetStatus - STATUS_RETURN_AT_EDGE"); - return 0; - - case BuiltIn_Commands_BaseClass.STATUS_ROTATE_X: - NotImplemented("llGetStatus - STATUS_ROTATE_X"); - return 0; - - case BuiltIn_Commands_BaseClass.STATUS_ROTATE_Y: - NotImplemented("llGetStatus - STATUS_ROTATE_Y"); - return 0; - - case BuiltIn_Commands_BaseClass.STATUS_ROTATE_Z: - NotImplemented("llGetStatus - STATUS_ROTATE_Z"); - return 0; - - case BuiltIn_Commands_BaseClass.STATUS_SANDBOX: - NotImplemented("llGetStatus - STATUS_SANDBOX"); - return 0; - } - return 0; - } - - public void llSetScale(LSL_Types.Vector3 scale) - { - m_host.AddScriptLPS(1); - SetScale(m_host, scale); - } - - private void SetScale(SceneObjectPart part, LSL_Types.Vector3 scale) - { - // TODO: this needs to trigger a persistance save as well - LLVector3 tmp = part.Scale; - tmp.X = (float)scale.x; - tmp.Y = (float)scale.y; - tmp.Z = (float)scale.z; - part.Scale = tmp; - part.SendFullUpdateToAllClients(); - } - - public LSL_Types.Vector3 llGetScale() - { - m_host.AddScriptLPS(1); - return new LSL_Types.Vector3(m_host.Scale.X, m_host.Scale.Y, m_host.Scale.Z); - } - - public void llSetColor(LSL_Types.Vector3 color, int face) - { - m_host.AddScriptLPS(1); - - SetColor(m_host, color, face); - } - - private void SetColor(SceneObjectPart part, LSL_Types.Vector3 color, int face) - { - LLObject.TextureEntry tex = part.Shape.Textures; - LLColor texcolor; - if (face > -1) - { - texcolor = tex.CreateFace((uint)face).RGBA; - texcolor.R = (float)Math.Abs(color.x - 1); - texcolor.G = (float)Math.Abs(color.y - 1); - texcolor.B = (float)Math.Abs(color.z - 1); - tex.FaceTextures[face].RGBA = texcolor; - part.UpdateTexture(tex); - return; - } - else if (face == -1) - { - for (uint i = 0; i < 32; i++) - { - if (tex.FaceTextures[i] != null) - { - texcolor = tex.FaceTextures[i].RGBA; - texcolor.R = (float)Math.Abs(color.x - 1); - texcolor.G = (float)Math.Abs(color.y - 1); - texcolor.B = (float)Math.Abs(color.z - 1); - tex.FaceTextures[i].RGBA = texcolor; - } - texcolor = tex.DefaultTexture.RGBA; - texcolor.R = (float)Math.Abs(color.x - 1); - texcolor.G = (float)Math.Abs(color.y - 1); - texcolor.B = (float)Math.Abs(color.z - 1); - tex.DefaultTexture.RGBA = texcolor; - } - part.UpdateTexture(tex); - return; - } - } - - public double llGetAlpha(int face) - { - m_host.AddScriptLPS(1); - LLObject.TextureEntry tex = m_host.Shape.Textures; - if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color - { - return (double)((tex.DefaultTexture.RGBA.A * 255) / 255); - } - if (face > -1) - { - return (double)((tex.GetFace((uint)face).RGBA.A * 255) / 255); - } - return 0; - } - - public void llSetAlpha(double alpha, int face) - { - m_host.AddScriptLPS(1); - - SetAlpha(m_host, alpha, face); - } - - private void SetAlpha(SceneObjectPart part, double alpha, int face) - { - LLObject.TextureEntry tex = part.Shape.Textures; - LLColor texcolor; - if (face > -1) - { - texcolor = tex.CreateFace((uint)face).RGBA; - texcolor.A = (float)Math.Abs(alpha - 1); - tex.FaceTextures[face].RGBA = texcolor; - part.UpdateTexture(tex); - return; - } - else if (face == -1) - { - for (int i = 0; i < 32; i++) - { - if (tex.FaceTextures[i] != null) - { - texcolor = tex.FaceTextures[i].RGBA; - texcolor.A = (float)Math.Abs(alpha - 1); - tex.FaceTextures[i].RGBA = texcolor; - } - } - texcolor = tex.DefaultTexture.RGBA; - texcolor.A = (float)Math.Abs(alpha - 1); - tex.DefaultTexture.RGBA = texcolor; - part.UpdateTexture(tex); - return; - } - } - - private void SetFlexi(SceneObjectPart part, bool flexi, int softness, float gravity, float friction, - float wind, float tension, LSL_Types.Vector3 Force) - { - if (part == null) - return; - - bool needs_fakedelete = false; - if (flexi) - { - if (!part.Shape.FlexiEntry) - { - needs_fakedelete = true; - } - part.Shape.FlexiEntry = true; // this setting flexi true isn't working, but the below parameters do - // work once the prim is already flexi - part.Shape.FlexiSoftness = softness; - part.Shape.FlexiGravity = gravity; - part.Shape.FlexiDrag = friction; - part.Shape.FlexiWind = wind; - part.Shape.FlexiTension = tension; - part.Shape.FlexiForceX = (float)Force.x; - part.Shape.FlexiForceY = (float)Force.y; - part.Shape.FlexiForceZ = (float)Force.z; - part.Shape.PathCurve = 0x80; - - } - else - { - if (part.Shape.FlexiEntry) - { - needs_fakedelete = true; - } - part.Shape.FlexiEntry = false; - } - - needs_fakedelete = false; - if (needs_fakedelete) - { - if (part.ParentGroup != null) - { - part.ParentGroup.FakeDeleteGroup(); - } - } - - part.ScheduleFullUpdate(); - } - - private void SetPointLight(SceneObjectPart part, bool light, LSL_Types.Vector3 color, float intensity, float radius, float falloff) - { - if (part == null) - return; - - if (light) - { - part.Shape.LightEntry = true; - part.Shape.LightColorR = (float)color.x; - part.Shape.LightColorG = (float)color.y; - part.Shape.LightColorB = (float)color.z; - part.Shape.LightIntensity = intensity; - part.Shape.LightRadius = radius; - part.Shape.LightFalloff = falloff; - } - else - { - part.Shape.LightEntry = false; - } - - part.ScheduleFullUpdate(); - } - - - - public LSL_Types.Vector3 llGetColor(int face) - { - m_host.AddScriptLPS(1); - LLObject.TextureEntry tex = m_host.Shape.Textures; - LLColor texcolor; - LSL_Types.Vector3 rgb; - if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color - { - texcolor = tex.DefaultTexture.RGBA; - rgb.x = (255 - (texcolor.R * 255)) / 255; - rgb.y = (255 - (texcolor.G * 255)) / 255; - rgb.z = (255 - (texcolor.B * 255)) / 255; - return rgb; - } - if (face > -1) - { - texcolor = tex.GetFace((uint)face).RGBA; - rgb.x = (255 - (texcolor.R * 255)) / 255; - rgb.y = (255 - (texcolor.G * 255)) / 255; - rgb.z = (255 - (texcolor.B * 255)) / 255; - return rgb; - } - else - { - return new LSL_Types.Vector3(); - } - } - - public void llSetTexture(string texture, int face) - { - m_host.AddScriptLPS(1); - SetTexture(m_host, texture, face); - } - - private void SetTexture(SceneObjectPart part, string texture, int face) - { - LLUUID textureID=new LLUUID(); - - if (!LLUUID.TryParse(texture, out textureID)) - { - textureID=InventoryKey(texture, (int)AssetType.Texture); - } - - if (textureID == LLUUID.Zero) - return; - - LLObject.TextureEntry tex = part.Shape.Textures; - - if (face > -1) - { - LLObject.TextureEntryFace texface = tex.CreateFace((uint)face); - texface.TextureID = textureID; - tex.FaceTextures[face] = texface; - part.UpdateTexture(tex); - return; - } - else if (face == -1) - { - for (uint i = 0; i < 32; i++) - { - if (tex.FaceTextures[i] != null) - { - tex.FaceTextures[i].TextureID = textureID; - } - } - tex.DefaultTexture.TextureID = textureID; - part.UpdateTexture(tex); - return; - } - } - - public void llScaleTexture(double u, double v, int face) - { - m_host.AddScriptLPS(1); - - ScaleTexture(m_host, u, v, face); - } - - private void ScaleTexture(SceneObjectPart part, double u, double v, int face) - { - LLObject.TextureEntry tex = part.Shape.Textures; - if (face > -1) - { - LLObject.TextureEntryFace texface = tex.CreateFace((uint)face); - texface.RepeatU = (float)u; - texface.RepeatV = (float)v; - tex.FaceTextures[face] = texface; - part.UpdateTexture(tex); - return; - } - if (face == -1) - { - for (int i = 0; i < 32; i++) - { - if (tex.FaceTextures[i] != null) - { - tex.FaceTextures[i].RepeatU = (float)u; - tex.FaceTextures[i].RepeatV = (float)v; - } - } - tex.DefaultTexture.RepeatU = (float)u; - tex.DefaultTexture.RepeatV = (float)v; - part.UpdateTexture(tex); - return; - } - } - - public void llOffsetTexture(double u, double v, int face) - { - m_host.AddScriptLPS(1); - OffsetTexture(m_host, u, v, face); - } - - private void OffsetTexture(SceneObjectPart part, double u, double v, int face) - { - LLObject.TextureEntry tex = part.Shape.Textures; - if (face > -1) - { - LLObject.TextureEntryFace texface = tex.CreateFace((uint)face); - texface.OffsetU = (float)u; - texface.OffsetV = (float)v; - tex.FaceTextures[face] = texface; - part.UpdateTexture(tex); - return; - } - if (face == -1) - { - for (int i = 0; i < 32; i++) - { - if (tex.FaceTextures[i] != null) - { - tex.FaceTextures[i].OffsetU = (float)u; - tex.FaceTextures[i].OffsetV = (float)v; - } - } - tex.DefaultTexture.OffsetU = (float)u; - tex.DefaultTexture.OffsetV = (float)v; - part.UpdateTexture(tex); - return; - } - } - - public void llRotateTexture(double rotation, int face) - { - m_host.AddScriptLPS(1); - RotateTexture(m_host, rotation, face); - } - - private void RotateTexture(SceneObjectPart part, double rotation, int face) - { - LLObject.TextureEntry tex = part.Shape.Textures; - if (face > -1) - { - LLObject.TextureEntryFace texface = tex.CreateFace((uint)face); - texface.Rotation = (float)rotation; - tex.FaceTextures[face] = texface; - part.UpdateTexture(tex); - return; - } - if (face == -1) - { - for (int i = 0; i < 32; i++) - { - if (tex.FaceTextures[i] != null) - { - tex.FaceTextures[i].Rotation = (float)rotation; - } - } - tex.DefaultTexture.Rotation = (float)rotation; - part.UpdateTexture(tex); - return; - } - } - - public string llGetTexture(int face) - { - m_host.AddScriptLPS(1); - LLObject.TextureEntry tex = m_host.Shape.Textures; - if (face == -1) - { - face = 0; - } - if (face > -1) - { - LLObject.TextureEntryFace texface; - texface = tex.GetFace((uint)face); - return texface.TextureID.ToString(); - } - else - { - return String.Empty; - } - } - - public void llSetPos(LSL_Types.Vector3 pos) - { - m_host.AddScriptLPS(1); - - SetPos(m_host, pos); - } - - private void SetPos(SceneObjectPart part, LSL_Types.Vector3 pos) - { - if (part.ParentID != 0) - { - part.UpdateOffSet(new LLVector3((float)pos.x, (float)pos.y, (float)pos.z)); - } - else - { - part.UpdateGroupPosition(new LLVector3((float)pos.x, (float)pos.y, (float)pos.z)); - } - } - - public LSL_Types.Vector3 llGetPos() - { - m_host.AddScriptLPS(1); - return new LSL_Types.Vector3(m_host.AbsolutePosition.X, - m_host.AbsolutePosition.Y, - m_host.AbsolutePosition.Z); - } - - public LSL_Types.Vector3 llGetLocalPos() - { - m_host.AddScriptLPS(1); - if (m_host.ParentID != 0) - { - return new LSL_Types.Vector3(m_host.OffsetPosition.X, - m_host.OffsetPosition.Y, - m_host.OffsetPosition.Z); - } - else - { - return new LSL_Types.Vector3(m_host.AbsolutePosition.X, - m_host.AbsolutePosition.Y, - m_host.AbsolutePosition.Z); - } - } - - public void llSetRot(LSL_Types.Quaternion rot) - { - m_host.AddScriptLPS(1); - - SetRot(m_host, rot); - } - - private void SetRot(SceneObjectPart part, LSL_Types.Quaternion rot) - { - part.UpdateRotation(new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s)); - // Update rotation does not move the object in the physics scene if it's a linkset. - part.ParentGroup.AbsolutePosition = part.ParentGroup.AbsolutePosition; - } - - public LSL_Types.Quaternion llGetRot() - { - m_host.AddScriptLPS(1); - LLQuaternion q = m_host.RotationOffset; - return new LSL_Types.Quaternion(q.X, q.Y, q.Z, q.W); - } - - public LSL_Types.Quaternion llGetLocalRot() - { - m_host.AddScriptLPS(1); - return new LSL_Types.Quaternion(m_host.RotationOffset.X, m_host.RotationOffset.Y, m_host.RotationOffset.Z, m_host.RotationOffset.W); - } - - public void llSetForce(LSL_Types.Vector3 force, int local) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetForce"); - } - - public LSL_Types.Vector3 llGetForce() - { - m_host.AddScriptLPS(1); - NotImplemented("llGetForce"); - return new LSL_Types.Vector3(); - } - - public LSL_Types.LSLInteger llTarget(LSL_Types.Vector3 position, double range) - { - m_host.AddScriptLPS(1); - return m_host.registerTargetWaypoint(new LLVector3((float)position.x, (float)position.y, (float)position.z), (float)range); - - } - - public void llTargetRemove(int number) - { - m_host.AddScriptLPS(1); - m_host.unregisterTargetWaypoint(number); - } - - public LSL_Types.LSLInteger llRotTarget(LSL_Types.Quaternion rot, double error) - { - m_host.AddScriptLPS(1); - NotImplemented("llRotTarget"); - return 0; - } - - public void llRotTargetRemove(int number) - { - m_host.AddScriptLPS(1); - NotImplemented("llRotTargetRemove"); - } - - public void llMoveToTarget(LSL_Types.Vector3 target, double tau) - { - m_host.AddScriptLPS(1); - m_host.MoveToTarget(new LLVector3((float)target.x, (float)target.y, (float)target.z), (float)tau); - } - - public void llStopMoveToTarget() - { - m_host.AddScriptLPS(1); - m_host.StopMoveToTarget(); - } - - public void llApplyImpulse(LSL_Types.Vector3 force, int local) - { - m_host.AddScriptLPS(1); - //No energy force yet - - if (force.x > 20000) - force.x = 20000; - if (force.y > 20000) - force.y = 20000; - if (force.z > 20000) - force.z = 20000; - - if (local == 1) - { - m_host.ApplyImpulse(new LLVector3((float)force.x, (float)force.y, (float)force.z), true); - } - else - { - - m_host.ApplyImpulse(new LLVector3((float)force.x,(float)force.y,(float)force.z), false); - } - } - - public void llApplyRotationalImpulse(LSL_Types.Vector3 force, int local) - { - m_host.AddScriptLPS(1); - NotImplemented("llApplyRotationalImpulse"); - } - - public void llSetTorque(LSL_Types.Vector3 torque, int local) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetTorque"); - } - - public LSL_Types.Vector3 llGetTorque() - { - m_host.AddScriptLPS(1); - NotImplemented("llGetTorque"); - return new LSL_Types.Vector3(); - } - - public void llSetForceAndTorque(LSL_Types.Vector3 force, LSL_Types.Vector3 torque, int local) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetForceAndTorque"); - } - - public LSL_Types.Vector3 llGetVel() - { - m_host.AddScriptLPS(1); - return new LSL_Types.Vector3(m_host.Velocity.X, m_host.Velocity.Y, m_host.Velocity.Z); - } - - public LSL_Types.Vector3 llGetAccel() - { - m_host.AddScriptLPS(1); - return new LSL_Types.Vector3(m_host.Acceleration.X, m_host.Acceleration.Y, m_host.Acceleration.Z); - } - - public LSL_Types.Vector3 llGetOmega() - { - m_host.AddScriptLPS(1); - return new LSL_Types.Vector3(m_host.RotationalVelocity.X, m_host.RotationalVelocity.Y, m_host.RotationalVelocity.Z); - } - - public double llGetTimeOfDay() - { - m_host.AddScriptLPS(1); - NotImplemented("llGetTimeOfDay"); - return 0; - } - - public double llGetWallclock() - { - m_host.AddScriptLPS(1); - return DateTime.Now.TimeOfDay.TotalSeconds; - } - - public double llGetTime() - { - m_host.AddScriptLPS(1); - TimeSpan ScriptTime = DateTime.Now - m_timer; - return (double)((ScriptTime.TotalMilliseconds / 1000)*World.TimeDilation); - } - - public void llResetTime() - { - m_host.AddScriptLPS(1); - m_timer = DateTime.Now; - } - - public double llGetAndResetTime() - { - m_host.AddScriptLPS(1); - TimeSpan ScriptTime = DateTime.Now - m_timer; - m_timer = DateTime.Now; - return (double)((ScriptTime.TotalMilliseconds / 1000)*World.TimeDilation); - } - - public void llSound() - { - m_host.AddScriptLPS(1); - // This function has been deprecated - // see http://www.lslwiki.net/lslwiki/wakka.php?wakka=llSound - Deprecated("llSound"); - } - - // Xantor 20080528 PlaySound updated so it accepts an objectinventory name -or- a key to a sound - // 20080530 Updated to remove code duplication - public void llPlaySound(string sound, double volume) - { - m_host.AddScriptLPS(1); - - // send the sound, once, to all clients in range - m_host.SendSound(KeyOrName(sound).ToString(), volume, false, 0); - } - - // Xantor 20080528 we should do this differently. - // 1) apply the sound to the object - // 2) schedule full update - // just sending the sound out once doesn't work so well when other avatars come in view later on - // or when the prim gets moved, changed, sat on, whatever - // see large number of mantises (mantes?) - // 20080530 Updated to remove code duplication - // 20080530 Stop sound if there is one, otherwise volume only changes don't work - public void llLoopSound(string sound, double volume) - { - m_host.AddScriptLPS(1); - - if (m_host.Sound != LLUUID.Zero) - llStopSound(); - - m_host.Sound = KeyOrName(sound); - m_host.SoundGain = volume; - m_host.SoundFlags = 1; // looping - m_host.SoundRadius = 20; // Magic number, 20 seems reasonable. Make configurable? - - m_host.ScheduleFullUpdate(); - m_host.SendFullUpdateToAllClients(); - } - - public void llLoopSoundMaster(string sound, double volume) - { - m_host.AddScriptLPS(1); - NotImplemented("llLoopSoundMaster"); - } - - public void llLoopSoundSlave(string sound, double volume) - { - m_host.AddScriptLPS(1); - NotImplemented("llLoopSoundSlave"); - } - - public void llPlaySoundSlave(string sound, double volume) - { - m_host.AddScriptLPS(1); - NotImplemented("llPlaySoundSlave"); - } - - public void llTriggerSound(string sound, double volume) - { - m_host.AddScriptLPS(1); - m_host.SendSound(sound, volume, true, 0); - } - - // Xantor 20080528: Clear prim data of sound instead - public void llStopSound() - { - m_host.AddScriptLPS(1); - - m_host.Sound = LLUUID.Zero; - m_host.SoundGain = 0; - m_host.SoundFlags = 0; - m_host.SoundRadius = 0; - - m_host.ScheduleFullUpdate(); - m_host.SendFullUpdateToAllClients(); - - // m_host.SendSound(LLUUID.Zero.ToString(), 1.0, false, 2); - } - - public void llPreloadSound(string sound) - { - m_host.AddScriptLPS(1); - m_host.PreloadSound(sound); - } - - /// - /// Return a portion of the designated string bounded by - /// inclusive indices (start and end). As usual, the negative - /// indices, and the tolerance for out-of-bound values, makes - /// this more complicated than it might otherwise seem. - /// - - public string llGetSubString(string src, int start, int end) - { - - m_host.AddScriptLPS(1); - - // Normalize indices (if negative). - // After normlaization they may still be - // negative, but that is now relative to - // the start, rather than the end, of the - // sequence. - - if (start < 0) - { - start = src.Length+start; - } - if (end < 0) - { - end = src.Length+end; - } - - // Conventional substring - if (start <= end) - { - // Implies both bounds are out-of-range. - if (end < 0 || start >= src.Length) - { - return String.Empty; - } - // If end is positive, then it directly - // corresponds to the lengt of the substring - // needed (plus one of course). BUT, it - // must be within bounds. - if (end >= src.Length) - { - end = src.Length-1; - } - - if (start < 0) - { - return src.Substring(0,end+1); - } - // Both indices are positive - return src.Substring(start, (end+1) - start); - } - - // Inverted substring (end < start) - else - { - // Implies both indices are below the - // lower bound. In the inverted case, that - // means the entire string will be returned - // unchanged. - if (start < 0) - { - return src; - } - // If both indices are greater than the upper - // bound the result may seem initially counter - // intuitive. - if (end >= src.Length) - { - return src; - } - - if (end < 0) - { - if (start < src.Length) - { - return src.Substring(start); - } - else - { - return String.Empty; - } - } - else - { - if (start < src.Length) - { - return src.Substring(0,end+1) + src.Substring(start); - } - else - { - return src.Substring(0,end+1); - } - } - } - } - - /// - /// Delete substring removes the specified substring bounded - /// by the inclusive indices start and end. Indices may be - /// negative (indicating end-relative) and may be inverted, - /// i.e. end < start. - /// - - public string llDeleteSubString(string src, int start, int end) - { - - m_host.AddScriptLPS(1); - - // Normalize indices (if negative). - // After normlaization they may still be - // negative, but that is now relative to - // the start, rather than the end, of the - // sequence. - if (start < 0) - { - start = src.Length+start; - } - if (end < 0) - { - end = src.Length+end; - } - // Conventionally delimited substring - if (start <= end) - { - // If both bounds are outside of the existing - // string, then return unchanges. - if (end < 0 || start >= src.Length) - { - return src; - } - // At least one bound is in-range, so we - // need to clip the out-of-bound argument. - if (start < 0) - { - start = 0; - } - - if (end >= src.Length) - { - end = src.Length-1; - } - - return src.Remove(start,end-start+1); - } - // Inverted substring - else - { - // In this case, out of bounds means that - // the existing string is part of the cut. - if (start < 0 || end >= src.Length) - { - return String.Empty; - } - - if (end > 0) - { - if (start < src.Length) - { - return src.Remove(start).Remove(0,end+1); - } - else - { - return src.Remove(0,end+1); - } - } - else - { - if (start < src.Length) - { - return src.Remove(start); - } - else - { - return src; - } - } - } - } - - /// - /// Insert string inserts the specified string identified by src - /// at the index indicated by index. Index may be negative, in - /// which case it is end-relative. The index may exceed either - /// string bound, with the result being a concatenation. - /// - - public string llInsertString(string dest, int index, string src) - { - - m_host.AddScriptLPS(1); - - // Normalize indices (if negative). - // After normlaization they may still be - // negative, but that is now relative to - // the start, rather than the end, of the - // sequence. - if (index < 0) - { - index = dest.Length+index; - - // Negative now means it is less than the lower - // bound of the string. - - if (index < 0) - { - return src+dest; - } - - } - - if (index >= dest.Length) - { - return dest+src; - } - - // The index is in bounds. - // In this case the index refers to the index that will - // be assigned to the first character of the inserted string. - // So unlike the other string operations, we do not add one - // to get the correct string length. - return dest.Substring(0,index)+src+dest.Substring(index); - - } - - public string llToUpper(string src) - { - m_host.AddScriptLPS(1); - return src.ToUpper(); - } - - public string llToLower(string src) - { - m_host.AddScriptLPS(1); - return src.ToLower(); - } - - public LSL_Types.LSLInteger llGiveMoney(string destination, int amount) - { - LLUUID invItemID=InventorySelf(); - if (invItemID == LLUUID.Zero) - return 0; - - m_host.AddScriptLPS(1); - - if (m_host.TaskInventory[invItemID].PermsGranter == LLUUID.Zero) - return 0; - - if ((m_host.TaskInventory[invItemID].PermsMask & BuiltIn_Commands_BaseClass.PERMISSION_DEBIT) == 0) - { - LSLError("No permissions to give money"); - return 0; - } - - LLUUID toID=new LLUUID(); - - if (!LLUUID.TryParse(destination, out toID)) - { - LSLError("Bad key in llGiveMoney"); - return 0; - } - - IMoneyModule money=World.RequestModuleInterface(); - - if (money == null) - { - NotImplemented("llGiveMoney"); - return 0; - } - - bool result=money.ObjectGiveMoney(m_host.ParentGroup.RootPart.UUID, m_host.ParentGroup.RootPart.OwnerID, toID, amount); - - if (result) - return 1; - - return 0; - } - - public void llMakeExplosion() - { - m_host.AddScriptLPS(1); - NotImplemented("llMakeExplosion"); - } - - public void llMakeFountain() - { - m_host.AddScriptLPS(1); - NotImplemented("llMakeFountain"); - } - - public void llMakeSmoke() - { - m_host.AddScriptLPS(1); - NotImplemented("llMakeSmoke"); - } - - public void llMakeFire() - { - m_host.AddScriptLPS(1); - NotImplemented("llMakeFire"); - } - - public void llRezObject(string inventory, LSL_Types.Vector3 pos, LSL_Types.Vector3 vel, LSL_Types.Quaternion rot, int param) - { - m_host.AddScriptLPS(1); - //NotImplemented("llRezObject"); - bool found = false; - - // Instead of using return;, I'm using continue; because in our TaskInventory implementation - // it's possible to have two items with the same task inventory name. - // this is an easter egg of sorts. - - foreach (KeyValuePair inv in m_host.TaskInventory) - { - if (inv.Value.Name == inventory) - { - // make sure we're an object. - if (inv.Value.InvType != (int)InventoryType.Object) - { - llSay(0, "Unable to create requested object. Object is missing from database."); - continue; - } - - LLVector3 llpos = new LLVector3((float)pos.x, (float)pos.y, (float)pos.z); - - // test if we're further away then 10m - if (Util.GetDistanceTo(llpos, m_host.AbsolutePosition) > 10) - return; // wiki says, if it's further away then 10m, silently fail. - - LLVector3 llvel = new LLVector3((float)vel.x, (float)vel.y, (float)vel.z); - - // need the magnitude later - float velmag = (float)Util.GetMagnitude(llvel); - - SceneObjectGroup new_group = World.RezObject(inv.Value, llpos, new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s), llvel, param); - - // If either of these are null, then there was an unknown error. - if (new_group == null) - continue; - if (new_group.RootPart == null) - continue; - - // objects rezzed with this method are die_at_edge by default. - new_group.RootPart.SetDieAtEdge(true); - - m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams( - "object_rez", new Object[] { - new LSL_Types.LSLString( - new_group.RootPart.UUID.ToString()) }, - new XDetectParams[0])); - - float groupmass = new_group.GetMass(); - - //Recoil. - llApplyImpulse(new LSL_Types.Vector3(llvel.X * groupmass, llvel.Y * groupmass, llvel.Z * groupmass), 0); - found = true; - //script delay - System.Threading.Thread.Sleep((int)((groupmass * velmag) / 10)); - break; - } - } - if (!found) - llSay(0, "Could not find object " + inventory); - } - - public void llLookAt(LSL_Types.Vector3 target, double strength, double damping) - { - m_host.AddScriptLPS(1); - NotImplemented("llLookAt"); - } - - public void llStopLookAt() - { - m_host.AddScriptLPS(1); - NotImplemented("llStopLookAt"); - } - - public void llSetTimerEvent(double sec) - { - m_host.AddScriptLPS(1); - // Setting timer repeat - m_ScriptEngine.m_ASYNCLSLCommandManager.m_Timer.SetTimerEvent(m_localID, m_itemID, sec); - } - - public void llSleep(double sec) - { - m_host.AddScriptLPS(1); - Thread.Sleep((int)(sec * 1000)); - } - - public double llGetMass() - { - m_host.AddScriptLPS(1); - return m_host.GetMass(); - } - - public void llCollisionFilter(string name, string id, int accept) - { - m_host.AddScriptLPS(1); - NotImplemented("llCollisionFilter"); - } - - public void llTakeControls(int controls, int accept, int pass_on) - { - if (!m_host.TaskInventory.ContainsKey(InventorySelf())) - { - return; - } - - if (m_host.TaskInventory[InventorySelf()].PermsGranter != LLUUID.Zero) - { - ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[InventorySelf()].PermsGranter); - - if (presence != null) - { - if ((m_host.TaskInventory[InventorySelf()].PermsMask & BuiltIn_Commands_BaseClass.PERMISSION_TAKE_CONTROLS) != 0) - { - presence.RegisterControlEventsToScript(controls, accept, pass_on, m_localID, m_itemID); - - } - } - } - - m_host.AddScriptLPS(1); - //NotImplemented("llTakeControls"); - } - - public void llReleaseControls() - { - m_host.AddScriptLPS(1); - - if (!m_host.TaskInventory.ContainsKey(InventorySelf())) - { - return; - } - - if (m_host.TaskInventory[InventorySelf()].PermsGranter != LLUUID.Zero) - { - ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[InventorySelf()].PermsGranter); - - if (presence != null) - { - if ((m_host.TaskInventory[InventorySelf()].PermsMask & BuiltIn_Commands_BaseClass.PERMISSION_TAKE_CONTROLS) != 0) - { - // Unregister controls from Presence - presence.UnRegisterControlEventsToScript(m_localID, m_itemID); - // Remove Take Control permission. - m_host.TaskInventory[InventorySelf()].PermsMask &= ~BuiltIn_Commands_BaseClass.PERMISSION_TAKE_CONTROLS; - } - } - } - } - - public void llAttachToAvatar(int attachment) - { - m_host.AddScriptLPS(1); - NotImplemented("llAttachToAvatar"); - } - - public void llDetachFromAvatar() - { - m_host.AddScriptLPS(1); - NotImplemented("llDetachFromAvatar"); - } - - public void llTakeCamera() - { - m_host.AddScriptLPS(1); - NotImplemented("llTakeCamera"); - } - - public void llReleaseCamera() - { - m_host.AddScriptLPS(1); - NotImplemented("llReleaseCamera"); - } - - public string llGetOwner() - { - m_host.AddScriptLPS(1); - - return m_host.ObjectOwner.ToString(); - } - - public void llInstantMessage(string user, string message) - { - m_host.AddScriptLPS(1); - - // We may be able to use ClientView.SendInstantMessage here, but we need a client instance. - // InstantMessageModule.OnInstantMessage searches through a list of scenes for a client matching the toAgent, - // but I don't think we have a list of scenes available from here. - // (We also don't want to duplicate the code in OnInstantMessage if we can avoid it.) - - // user is a UUID - - // TODO: figure out values for client, fromSession, and imSessionID - // client.SendInstantMessage(m_host.UUID, fromSession, message, user, imSessionID, m_host.Name, AgentManager.InstantMessageDialog.MessageFromAgent, (uint)Util.UnixTimeSinceEpoch()); - LLUUID friendTransactionID = LLUUID.Random(); - - //m_pendingFriendRequests.Add(friendTransactionID, fromAgentID); - - GridInstantMessage msg = new GridInstantMessage(); - msg.fromAgentID = new Guid(m_host.UUID.ToString()); // fromAgentID.UUID; - msg.fromAgentSession = new Guid(friendTransactionID.ToString());// fromAgentSession.UUID; - msg.toAgentID = new Guid(user); // toAgentID.UUID; - msg.imSessionID = new Guid(friendTransactionID.ToString()); // This is the item we're mucking with here -// Console.WriteLine("[Scripting IM]: From:" + msg.fromAgentID.ToString() + " To: " + msg.toAgentID.ToString() + " Session:" + msg.imSessionID.ToString() + " Message:" + message); -// Console.WriteLine("[Scripting IM]: Filling Session: " + msg.imSessionID.ToString()); - msg.timestamp = (uint)Util.UnixTimeSinceEpoch();// timestamp; - //if (client != null) - //{ - msg.fromAgentName = m_host.Name;//client.FirstName + " " + client.LastName;// fromAgentName; - //} - //else - //{ - // msg.fromAgentName = "(hippos)";// Added for posterity. This means that we can't figure out who sent it - //} - msg.message = message; - msg.dialog = (byte)19; // messgage from script ??? // dialog; - msg.fromGroup = false;// fromGroup; - msg.offline = (byte)0; //offline; - msg.ParentEstateID = 0; //ParentEstateID; - msg.Position = new sLLVector3();// new sLLVector3(m_host.AbsolutePosition); - msg.RegionID = World.RegionInfo.RegionID.UUID;//RegionID.UUID; - msg.binaryBucket = new byte[0];// binaryBucket; - World.TriggerGridInstantMessage(msg, InstantMessageReceiver.IMModule); - // NotImplemented("llInstantMessage"); - } - - public void llEmail(string address, string subject, string message) - { - m_host.AddScriptLPS(1); - NotImplemented("llEmail"); - } - - public void llGetNextEmail(string address, string subject) - { - m_host.AddScriptLPS(1); - NotImplemented("llGetNextEmail"); - } - - public string llGetKey() - { - m_host.AddScriptLPS(1); - return m_host.UUID.ToString(); - } - - public void llSetBuoyancy(double buoyancy) - { - m_host.AddScriptLPS(1); - if (m_host.ParentGroup != null) - { - if (m_host.ParentGroup.RootPart != null) - { - m_host.ParentGroup.RootPart.SetBuoyancy((float)buoyancy); - } - } - } - - - - public void llSetHoverHeight(double height, int water, double tau) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetHoverHeight"); - } - - public void llStopHover() - { - m_host.AddScriptLPS(1); - NotImplemented("llStopHover"); - } - - public void llMinEventDelay(double delay) - { - m_host.AddScriptLPS(1); - NotImplemented("llMinEventDelay"); - } - - public void llSoundPreload() - { - m_host.AddScriptLPS(1); - NotImplemented("llSoundPreload"); - } - - public void llRotLookAt(LSL_Types.Quaternion target, double strength, double damping) - { - m_host.AddScriptLPS(1); - NotImplemented("llRotLookAt"); - } - - public LSL_Types.LSLInteger llStringLength(string str) - { - m_host.AddScriptLPS(1); - if (str.Length > 0) - { - return str.Length; - } - else - { - return 0; - } - } - - public void llStartAnimation(string anim) - { - m_host.AddScriptLPS(1); - - LLUUID invItemID=InventorySelf(); - if (invItemID == LLUUID.Zero) - return; - - if (m_host.TaskInventory[invItemID].PermsGranter == LLUUID.Zero) - return; - - if ((m_host.TaskInventory[invItemID].PermsMask & BuiltIn_Commands_BaseClass.PERMISSION_TRIGGER_ANIMATION) != 0) - { - ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[invItemID].PermsGranter); - - if (presence != null) - { - // Do NOT try to parse LLUUID, animations cannot be triggered by ID - LLUUID animID=InventoryKey(anim, (int)AssetType.Animation); - if (animID == LLUUID.Zero) - presence.AddAnimation(anim); - else - presence.AddAnimation(animID); - } - } - } - - public void llStopAnimation(string anim) - { - m_host.AddScriptLPS(1); - - LLUUID invItemID=InventorySelf(); - if (invItemID == LLUUID.Zero) - return; - - if (m_host.TaskInventory[invItemID].PermsGranter == LLUUID.Zero) - return; - - if ((m_host.TaskInventory[invItemID].PermsMask & BuiltIn_Commands_BaseClass.PERMISSION_TRIGGER_ANIMATION) != 0) - { - LLUUID animID = new LLUUID(); - - if (!LLUUID.TryParse(anim, out animID)) - { - animID=InventoryKey(anim); - } - - if (animID == LLUUID.Zero) - return; - - ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[invItemID].PermsGranter); - - if (presence != null) - { - if (animID == LLUUID.Zero) - presence.RemoveAnimation(anim); - else - presence.RemoveAnimation(animID); - } - } - } - - public void llPointAt() - { - m_host.AddScriptLPS(1); - NotImplemented("llPointAt"); - } - - public void llStopPointAt() - { - m_host.AddScriptLPS(1); - NotImplemented("llStopPointAt"); - } - - public void llTargetOmega(LSL_Types.Vector3 axis, double spinrate, double gain) - { - m_host.AddScriptLPS(1); - m_host.RotationalVelocity = new LLVector3((float)(axis.x * spinrate), (float)(axis.y * spinrate), (float)(axis.z * spinrate)); - m_host.AngularVelocity = new LLVector3((float)(axis.x * spinrate), (float)(axis.y * spinrate), (float)(axis.z * spinrate)); - m_host.ScheduleTerseUpdate(); - m_host.SendTerseUpdateToAllClients(); - } - - public LSL_Types.LSLInteger llGetStartParameter() - { - m_host.AddScriptLPS(1); - // NotImplemented("llGetStartParameter"); - return m_host.ParentGroup.StartParameter; - } - - public void llGodLikeRezObject(string inventory, LSL_Types.Vector3 pos) - { - m_host.AddScriptLPS(1); - NotImplemented("llGodLikeRezObject"); - } - - public void llRequestPermissions(string agent, int perm) - { - LLUUID agentID=new LLUUID(); - - if (!LLUUID.TryParse(agent, out agentID)) - return; - - LLUUID invItemID=InventorySelf(); - - if (invItemID == LLUUID.Zero) - return; // Not in a prim? How?? - - if (agentID == LLUUID.Zero || perm == 0) // Releasing permissions - { - m_host.TaskInventory[invItemID].PermsGranter=LLUUID.Zero; - m_host.TaskInventory[invItemID].PermsMask=0; - - m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams( - "run_time_permissions", new Object[] { - new LSL_Types.LSLInteger(0) }, - new XDetectParams[0])); - - return; - } - - m_host.AddScriptLPS(1); - - if (m_host.ParentGroup.RootPart.m_IsAttachment && agent == m_host.ParentGroup.RootPart.m_attachedAvatar) - { - // When attached, certain permissions are implicit if requested from owner - int implicitPerms = BuiltIn_Commands_BaseClass.PERMISSION_TAKE_CONTROLS | - BuiltIn_Commands_BaseClass.PERMISSION_TRIGGER_ANIMATION | - BuiltIn_Commands_BaseClass.PERMISSION_ATTACH; - - if ((perm & (~implicitPerms)) == 0) // Requested only implicit perms - { - m_host.TaskInventory[invItemID].PermsGranter=agentID; - m_host.TaskInventory[invItemID].PermsMask=perm; - - m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams( - "run_time_permissions", new Object[] { - new LSL_Types.LSLInteger(perm) }, - new XDetectParams[0])); - - return; - } - } - else if (m_host.m_sitTargetAvatar == agentID) // Sitting avatar - { - // When agent is sitting, certain permissions are implicit if requested from sitting agent - int implicitPerms = BuiltIn_Commands_BaseClass.PERMISSION_TRIGGER_ANIMATION | - BuiltIn_Commands_BaseClass.PERMISSION_TRACK_CAMERA; - - if ((perm & (~implicitPerms)) == 0) // Requested only implicit perms - { - m_host.TaskInventory[invItemID].PermsGranter=agentID; - m_host.TaskInventory[invItemID].PermsMask=perm; - - m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams( - "run_time_permissions", new Object[] { - new LSL_Types.LSLInteger(perm) }, - new XDetectParams[0])); - - return; - } - } - - ScenePresence presence = World.GetScenePresence(agentID); - - if (presence != null) - { - string ownerName=resolveName(m_host.ParentGroup.RootPart.OwnerID); - if (ownerName == String.Empty) - ownerName="(hippos)"; - - if (!m_waitingForScriptAnswer) - { - m_host.TaskInventory[invItemID].PermsGranter=agentID; - m_host.TaskInventory[invItemID].PermsMask=0; - presence.ControllingClient.OnScriptAnswer+=handleScriptAnswer; - m_waitingForScriptAnswer=true; - } - - presence.ControllingClient.SendScriptQuestion(m_host.UUID, m_host.ParentGroup.RootPart.Name, ownerName, invItemID, perm); - return; - } - - // Requested agent is not in range, refuse perms - m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams( - "run_time_permissions", new Object[] { - new LSL_Types.LSLInteger(0) }, - new XDetectParams[0])); - } - - void handleScriptAnswer(IClientAPI client, LLUUID taskID, LLUUID itemID, int answer) - { - if (taskID != m_host.UUID) - return; - - LLUUID invItemID=InventorySelf(); - - if (invItemID == LLUUID.Zero) - return; - - client.OnScriptAnswer-=handleScriptAnswer; - m_waitingForScriptAnswer=false; - - m_host.TaskInventory[invItemID].PermsMask=answer; - m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams( - "run_time_permissions", new Object[] { - new LSL_Types.LSLInteger(answer) }, - new XDetectParams[0])); - } - - public string llGetPermissionsKey() - { - m_host.AddScriptLPS(1); - - foreach (TaskInventoryItem item in m_host.TaskInventory.Values) - { - if (item.Type == 10 && item.ItemID == m_itemID) - { - return item.PermsGranter.ToString(); - } - } - - return LLUUID.Zero.ToString(); - } - - public LSL_Types.LSLInteger llGetPermissions() - { - m_host.AddScriptLPS(1); - - foreach (TaskInventoryItem item in m_host.TaskInventory.Values) - { - if (item.Type == 10 && item.ItemID == m_itemID) - { - return item.PermsMask; - } - } - - return 0; - } - - public LSL_Types.LSLInteger llGetLinkNumber() - { - m_host.AddScriptLPS(1); - - if (m_host.ParentGroup.Children.Count > 0) - { - return m_host.LinkNum + 1; - } - else - { - return 0; - } - } - - public void llSetLinkColor(int linknumber, LSL_Types.Vector3 color, int face) - { - m_host.AddScriptLPS(1); - SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknumber); - if (linknumber > -1) - { - LLObject.TextureEntry tex = part.Shape.Textures; - LLColor texcolor; - if (face > -1) - { - texcolor = tex.CreateFace((uint)face).RGBA; - texcolor.R = (float)Math.Abs(color.x - 1); - texcolor.G = (float)Math.Abs(color.y - 1); - texcolor.B = (float)Math.Abs(color.z - 1); - tex.FaceTextures[face].RGBA = texcolor; - part.UpdateTexture(tex); - return; - } - else if (face == -1) - { - texcolor = tex.DefaultTexture.RGBA; - texcolor.R = (float)Math.Abs(color.x - 1); - texcolor.G = (float)Math.Abs(color.y - 1); - texcolor.B = (float)Math.Abs(color.z - 1); - tex.DefaultTexture.RGBA = texcolor; - for (uint i = 0; i < 32; i++) - { - if (tex.FaceTextures[i] != null) - { - texcolor = tex.FaceTextures[i].RGBA; - texcolor.R = (float)Math.Abs(color.x - 1); - texcolor.G = (float)Math.Abs(color.y - 1); - texcolor.B = (float)Math.Abs(color.z - 1); - tex.FaceTextures[i].RGBA = texcolor; - } - } - texcolor = tex.DefaultTexture.RGBA; - texcolor.R = (float)Math.Abs(color.x - 1); - texcolor.G = (float)Math.Abs(color.y - 1); - texcolor.B = (float)Math.Abs(color.z - 1); - tex.DefaultTexture.RGBA = texcolor; - part.UpdateTexture(tex); - return; - } - return; - } - else if (linknumber == -1) - { - int num = m_host.ParentGroup.PrimCount; - for (int w = 0; w < num; w++) - { - linknumber = w; - part = m_host.ParentGroup.GetLinkNumPart(linknumber); - LLObject.TextureEntry tex = part.Shape.Textures; - LLColor texcolor; - if (face > -1) - { - texcolor = tex.CreateFace((uint)face).RGBA; - texcolor.R = (float)Math.Abs(color.x - 1); - texcolor.G = (float)Math.Abs(color.y - 1); - texcolor.B = (float)Math.Abs(color.z - 1); - tex.FaceTextures[face].RGBA = texcolor; - part.UpdateTexture(tex); - } - else if (face == -1) - { - texcolor = tex.DefaultTexture.RGBA; - texcolor.R = (float)Math.Abs(color.x - 1); - texcolor.G = (float)Math.Abs(color.y - 1); - texcolor.B = (float)Math.Abs(color.z - 1); - tex.DefaultTexture.RGBA = texcolor; - for (uint i = 0; i < 32; i++) - { - if (tex.FaceTextures[i] != null) - { - texcolor = tex.FaceTextures[i].RGBA; - texcolor.R = (float)Math.Abs(color.x - 1); - texcolor.G = (float)Math.Abs(color.y - 1); - texcolor.B = (float)Math.Abs(color.z - 1); - tex.FaceTextures[i].RGBA = texcolor; - } - } - texcolor = tex.DefaultTexture.RGBA; - texcolor.R = (float)Math.Abs(color.x - 1); - texcolor.G = (float)Math.Abs(color.y - 1); - texcolor.B = (float)Math.Abs(color.z - 1); - tex.DefaultTexture.RGBA = texcolor; - part.UpdateTexture(tex); - } - } - return; - } - } - - public void llCreateLink(string target, int parent) - { - m_host.AddScriptLPS(1); - NotImplemented("llCreateLink"); - } - - public void llBreakLink(int linknum) - { - m_host.AddScriptLPS(1); - NotImplemented("llBreakLink"); - } - - public void llBreakAllLinks() - { - m_host.AddScriptLPS(1); - NotImplemented("llBreakAllLinks"); - } - - public string llGetLinkKey(int linknum) - { - m_host.AddScriptLPS(1); - SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknum); - if (part != null) - { - return part.UUID.ToString(); - } - else - { - return LLUUID.Zero.ToString(); - } - } - - public string llGetLinkName(int linknum) - { - m_host.AddScriptLPS(1); - SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknum); - if (part != null) - { - return part.Name; - } - else - { - return LLUUID.Zero.ToString(); - } - } - - public LSL_Types.LSLInteger llGetInventoryNumber(int type) - { - m_host.AddScriptLPS(1); - int count = 0; - foreach (KeyValuePair inv in m_host.TaskInventory) - { - if (inv.Value.Type == type || type == -1) - { - count = count + 1; - } - } - return count; - } - - public string llGetInventoryName(int type, int number) - { - m_host.AddScriptLPS(1); - ArrayList keys = new ArrayList(); - foreach (KeyValuePair inv in m_host.TaskInventory) - { - if (inv.Value.Type == type || type == -1) - { - keys.Add(inv.Value.Name); - } - } - if (keys.Count == 0) - { - return String.Empty; - } - keys.Sort(); - if (keys.Count > number) - { - return (string)keys[number]; - } - return String.Empty; - } - - public void llSetScriptState(string name, int run) - { - LLUUID item; - - m_host.AddScriptLPS(1); - - // These functions are supposed to be robust, - // so get the state one step at a time. - - if ((item = ScriptByName(name)) != LLUUID.Zero) - { - m_ScriptEngine.SetScriptState(item, run == 0 ? false : true); - } - else - { - ShoutError("llSetScriptState: script "+name+" not found"); - } - } - - public double llGetEnergy() - { - m_host.AddScriptLPS(1); - // TODO: figure out real energy value - return 1.0f; - } - - public void llGiveInventory(string destination, string inventory) - { - m_host.AddScriptLPS(1); - NotImplemented("llGiveInventory"); - } - - public void llRemoveInventory(string item) - { - m_host.AddScriptLPS(1); - NotImplemented("llRemoveInventory"); - } - - public void llSetText(string text, LSL_Types.Vector3 color, double alpha) - { - m_host.AddScriptLPS(1); - Vector3 av3 = new Vector3((float)color.x, (float)color.y, (float)color.z); - m_host.SetText(text, av3, alpha); - } - - public double llWater(LSL_Types.Vector3 offset) - { - m_host.AddScriptLPS(1); - return World.RegionInfo.EstateSettings.waterHeight; - } - - public void llPassTouches(int pass) - { - m_host.AddScriptLPS(1); - NotImplemented("llPassTouches"); - } - - public string llRequestAgentData(string id, int data) - { - m_host.AddScriptLPS(1); - - UserProfileData userProfile = - World.CommsManager.UserService.GetUserProfile(id); - - UserAgentData userAgent = - World.CommsManager.UserService.GetAgentByUUID(id); - - if (userProfile == null || userAgent == null) - return LLUUID.Zero.ToString(); - - string reply = String.Empty; - - switch (data) - { - case 1: // DATA_ONLINE (0|1) - // TODO: implement fetching of this information - if (userProfile.CurrentAgent.AgentOnline) - reply = "1"; - else - reply = "0"; - break; - case 2: // DATA_NAME (First Last) - reply = userProfile.FirstName + " " + userProfile.SurName; - break; - case 3: // DATA_BORN (YYYY-MM-DD) - DateTime born = new DateTime(1970, 1, 1, 0, 0, 0, 0); - born = born.AddSeconds(userProfile.Created); - reply = born.ToString("yyyy-MM-dd"); - break; - case 4: // DATA_RATING (0,0,0,0,0,0) - reply = "0,0,0,0,0,0"; - break; - case 8: // DATA_PAYINFO (0|1|2|3) - reply = "0"; - break; - default: - return LLUUID.Zero.ToString(); // Raise no event - } - - LLUUID rq = LLUUID.Random(); - - LLUUID tid = m_ScriptEngine.m_ASYNCLSLCommandManager. - m_Dataserver.RegisterRequest(m_localID, - m_itemID, rq.ToString()); - - m_ScriptEngine.m_ASYNCLSLCommandManager. - m_Dataserver.DataserverReply(rq.ToString(), reply); - - return tid.ToString(); - } - - public string llRequestInventoryData(string name) - { - m_host.AddScriptLPS(1); - - foreach (TaskInventoryItem item in m_host.TaskInventory.Values) - { - if (item.Type == 3 && item.Name == name) - { - LLUUID tid = m_ScriptEngine.m_ASYNCLSLCommandManager. - m_Dataserver.RegisterRequest(m_localID, - m_itemID, item.AssetID.ToString()); - - LLVector3 region = new LLVector3( - World.RegionInfo.RegionLocX * Constants.RegionSize, - World.RegionInfo.RegionLocY * Constants.RegionSize, - 0); - - World.AssetCache.GetAsset(item.AssetID, - delegate(LLUUID i, AssetBase a) - { - AssetLandmark lm = new AssetLandmark(a); - - region += lm.Position; - - string reply = region.ToString(); - - m_ScriptEngine.m_ASYNCLSLCommandManager. - m_Dataserver.DataserverReply(i.ToString(), - reply); - }, false); - - return tid.ToString(); - } - } - - return String.Empty; - } - - public void llSetDamage(double damage) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetDamage"); - } - - public void llTeleportAgentHome(string agent) - { - m_host.AddScriptLPS(1); - NotImplemented("llTeleportAgentHome"); - } - - public void llModifyLand(int action, int brush) - { - m_host.AddScriptLPS(1); - World.ExternalChecks.ExternalChecksCanTerraformLand(m_host.OwnerID, new LLVector3(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, 0)); - } - - public void llCollisionSound(string impact_sound, double impact_volume) - { - m_host.AddScriptLPS(1); - NotImplemented("llCollisionSound"); - } - - public void llCollisionSprite(string impact_sprite) - { - m_host.AddScriptLPS(1); - NotImplemented("llCollisionSprite"); - } - - public string llGetAnimation(string id) - { - m_host.AddScriptLPS(1); - NotImplemented("llGetAnimation"); - return String.Empty; - } - - public void llResetScript() - { - m_host.AddScriptLPS(1); - m_ScriptEngine.ResetScript(m_itemID); - } - - public void llMessageLinked(int linknum, int num, string msg, string id) - { - - m_host.AddScriptLPS(1); - - uint partLocalID; - LLUUID partItemID; - - switch ((int)linknum) - { - - case (int)BuiltIn_Commands_BaseClass.LINK_ROOT: - - SceneObjectPart part = m_host.ParentGroup.RootPart; - - foreach (TaskInventoryItem item in part.TaskInventory.Values) - { - if (item.Type == 10) - { - partLocalID = part.LocalId; - partItemID = item.ItemID; - - object[] resobj = new object[] - { - new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id) - }; - - m_ScriptEngine.PostScriptEvent(partItemID, - new XEventParams("link_message", - resobj, new XDetectParams[0])); - } - } - - break; - - case (int)BuiltIn_Commands_BaseClass.LINK_SET: - - foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts()) - { - - foreach (TaskInventoryItem item in partInst.TaskInventory.Values) - { - if (item.Type == 10) - { - partLocalID = partInst.LocalId; - partItemID = item.ItemID; - Object[] resobj = new object[] - { - new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id) - }; - - m_ScriptEngine.PostScriptEvent(partItemID, - new XEventParams("link_message", - resobj, new XDetectParams[0])); - } - } - } - - break; - - case (int)BuiltIn_Commands_BaseClass.LINK_ALL_OTHERS: - - foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts()) - { - - if (partInst.LocalId != m_host.LocalId) - { - - foreach (TaskInventoryItem item in partInst.TaskInventory.Values) - { - if (item.Type == 10) - { - partLocalID = partInst.LocalId; - partItemID = item.ItemID; - Object[] resobj = new object[] - { - new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id) - }; - - m_ScriptEngine.PostScriptEvent(partItemID, - new XEventParams("link_message", - resobj, new XDetectParams[0])); - } - } - - } - } - - break; - - case (int)BuiltIn_Commands_BaseClass.LINK_ALL_CHILDREN: - - foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts()) - { - - if (partInst.LocalId != m_host.ParentGroup.RootPart.LocalId) - { - - foreach (TaskInventoryItem item in partInst.TaskInventory.Values) - { - if (item.Type == 10) - { - partLocalID = partInst.LocalId; - partItemID = item.ItemID; - Object[] resobj = new object[] - { - new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id) - }; - - m_ScriptEngine.PostScriptEvent(partItemID, - new XEventParams("link_message", - resobj, new XDetectParams[0])); - } - } - - } - } - - break; - - case (int)BuiltIn_Commands_BaseClass.LINK_THIS: - - foreach (TaskInventoryItem item in m_host.TaskInventory.Values) - { - if (item.Type == 10) - { - partItemID = item.ItemID; - - object[] resobj = new object[] - { - new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id) - }; - - m_ScriptEngine.PostScriptEvent(partItemID, - new XEventParams("link_message", - resobj, new XDetectParams[0])); - } - } - - break; - - default: - - foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts()) - { - - if ((partInst.LinkNum + 1) == linknum) - { - - foreach (TaskInventoryItem item in partInst.TaskInventory.Values) - { - if (item.Type == 10) - { - partLocalID = partInst.LocalId; - partItemID = item.ItemID; - Object[] resObjDef = new object[] - { - new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id) - }; - - m_ScriptEngine.PostScriptEvent(partItemID, - new XEventParams("link_message", - resObjDef, new XDetectParams[0])); - } - } - - } - } - - break; - - } - - } - - public void llPushObject(string target, LSL_Types.Vector3 impulse, LSL_Types.Vector3 ang_impulse, int local) - { - m_host.AddScriptLPS(1); - NotImplemented("llPushObject"); - } - - public void llPassCollisions(int pass) - { - m_host.AddScriptLPS(1); - NotImplemented("llPassCollisions"); - } - - public string llGetScriptName() - { - - string result = String.Empty; - - m_host.AddScriptLPS(1); - - foreach (TaskInventoryItem item in m_host.TaskInventory.Values) - { - if (item.Type == 10 && item.ItemID == m_itemID) - { - result = item.Name!=null?item.Name:String.Empty; - break; - } - } - - return result; - - } - - public LSL_Types.LSLInteger llGetNumberOfSides() - { - m_host.AddScriptLPS(1); - NotImplemented("llGetNumberOfSides"); - return 0; - } - - - /* The new / changed functions were tested with the following LSL script: - - default - { - state_entry() - { - rotation rot = llEuler2Rot(<0,70,0> * DEG_TO_RAD); - - llOwnerSay("to get here, we rotate over: "+ (string) llRot2Axis(rot)); - llOwnerSay("and we rotate for: "+ (llRot2Angle(rot) * RAD_TO_DEG)); - - // convert back and forth between quaternion <-> vector and angle - - rotation newrot = llAxisAngle2Rot(llRot2Axis(rot),llRot2Angle(rot)); - - llOwnerSay("Old rotation was: "+(string) rot); - llOwnerSay("re-converted rotation is: "+(string) newrot); - - llSetRot(rot); // to check the parameters in the prim - } - } - */ - - - - // Xantor 29/apr/2008 - // Returns rotation described by rotating angle radians about axis. - // q = cos(a/2) + i (x * sin(a/2)) + j (y * sin(a/2)) + k (z * sin(a/2)) - public LSL_Types.Quaternion llAxisAngle2Rot(LSL_Types.Vector3 axis, double angle) - { - m_host.AddScriptLPS(1); - - double x, y, z, s, t; - - s = Math.Cos(angle / 2); - t = Math.Sin(angle / 2); // temp value to avoid 2 more sin() calcs - x = axis.x * t; - y = axis.y * t; - z = axis.z * t; - - return new LSL_Types.Quaternion(x,y,z,s); - } - - - // Xantor 29/apr/2008 - // converts a Quaternion to X,Y,Z axis rotations - public LSL_Types.Vector3 llRot2Axis(LSL_Types.Quaternion rot) - { - m_host.AddScriptLPS(1); - double x,y,z; - - if (rot.s > 1) // normalization needed - { - double length = Math.Sqrt(rot.x * rot.x + rot.y * rot.y + - rot.z * rot.z + rot.s * rot.s); - - rot.x /= length; - rot.y /= length; - rot.z /= length; - rot.s /= length; - - } - - double angle = 2 * Math.Acos(rot.s); - double s = Math.Sqrt(1 - rot.s * rot.s); - if (s < 0.001) - { - x = 1; - y = z = 0; - } - else - { - x = rot.x / s; // normalise axis - y = rot.y / s; - z = rot.z / s; - } - - - return new LSL_Types.Vector3(x,y,z); - - -// NotImplemented("llRot2Axis"); - } - - - // Returns the angle of a quaternion (see llRot2Axis for the axis) - public double llRot2Angle(LSL_Types.Quaternion rot) - { - m_host.AddScriptLPS(1); - - if (rot.s > 1) // normalization needed - { - double length = Math.Sqrt(rot.x * rot.x + rot.y * rot.y + - rot.z * rot.z + rot.s * rot.s); - - rot.x /= length; - rot.y /= length; - rot.z /= length; - rot.s /= length; - - } - - double angle = 2 * Math.Acos(rot.s); - - return angle; - -// NotImplemented("llRot2Angle"); - } - - public double llAcos(double val) - { - m_host.AddScriptLPS(1); - return (double)Math.Acos(val); - } - - public double llAsin(double val) - { - m_host.AddScriptLPS(1); - return (double)Math.Asin(val); - } - - // Xantor 30/apr/2008 - public double llAngleBetween(LSL_Types.Quaternion a, LSL_Types.Quaternion b) - { - m_host.AddScriptLPS(1); - - return (double) Math.Acos(a.x * b.x + a.y * b.y + a.z * b.z + a.s * b.s) * 2; - } - - public string llGetInventoryKey(string name) - { - m_host.AddScriptLPS(1); - foreach (KeyValuePair inv in m_host.TaskInventory) - { - if (inv.Value.Name == name) - { - if ((inv.Value.OwnerMask & (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify)) == (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify)) - { - return inv.Value.AssetID.ToString(); - } - else - { - return LLUUID.Zero.ToString(); - } - } - } - return LLUUID.Zero.ToString(); - } - - public void llAllowInventoryDrop(int add) - { - m_host.AddScriptLPS(1); - NotImplemented("llAllowInventoryDrop"); - } - - public LSL_Types.Vector3 llGetSunDirection() - { - m_host.AddScriptLPS(1); - - LSL_Types.Vector3 SunDoubleVector3; - LLVector3 SunFloatVector3; - - // sunPosition estate setting is set in OpenSim.Region.Environment.Modules.SunModule - // have to convert from LLVector3 (float) to LSL_Types.Vector3 (double) - SunFloatVector3 = World.RegionInfo.EstateSettings.sunPosition; - SunDoubleVector3.x = (double)SunFloatVector3.X; - SunDoubleVector3.y = (double)SunFloatVector3.Y; - SunDoubleVector3.z = (double)SunFloatVector3.Z; - - return SunDoubleVector3; - } - - public LSL_Types.Vector3 llGetTextureOffset(int face) - { - m_host.AddScriptLPS(1); - LLObject.TextureEntry tex = m_host.Shape.Textures; - LSL_Types.Vector3 offset; - if (face == -1) - { - face = 0; - } - offset.x = tex.GetFace((uint)face).OffsetU; - offset.y = tex.GetFace((uint)face).OffsetV; - offset.z = 0.0; - return offset; - } - - public LSL_Types.Vector3 llGetTextureScale(int side) - { - m_host.AddScriptLPS(1); - LLObject.TextureEntry tex = m_host.Shape.Textures; - LSL_Types.Vector3 scale; - if (side == -1) - { - side = 0; - } - scale.x = tex.GetFace((uint)side).RepeatU; - scale.y = tex.GetFace((uint)side).RepeatV; - scale.z = 0.0; - return scale; - } - - public double llGetTextureRot(int face) - { - m_host.AddScriptLPS(1); - LLObject.TextureEntry tex = m_host.Shape.Textures; - if (face == -1) - { - face = 0; - } - return tex.GetFace((uint)face).Rotation; - } - - public LSL_Types.LSLInteger llSubStringIndex(string source, string pattern) - { - m_host.AddScriptLPS(1); - return source.IndexOf(pattern); - } - - public string llGetOwnerKey(string id) - { - m_host.AddScriptLPS(1); - LLUUID key = new LLUUID(); - if (LLUUID.TryParse(id, out key)) - { - return World.GetSceneObjectPart(World.Entities[key].LocalId).OwnerID.ToString(); - } - else - { - return LLUUID.Zero.ToString(); - } - } - - public LSL_Types.Vector3 llGetCenterOfMass() - { - m_host.AddScriptLPS(1); - NotImplemented("llGetCenterOfMass"); - return new LSL_Types.Vector3(); - } - - public LSL_Types.list llListSort(LSL_Types.list src, int stride, int ascending) - { - m_host.AddScriptLPS(1); - return src.Sort(stride, ascending); - } - - public LSL_Types.LSLInteger llGetListLength(LSL_Types.list src) - { - m_host.AddScriptLPS(1); - return src.Length; - } - - public LSL_Types.LSLInteger llList2Integer(LSL_Types.list src, int index) - { - m_host.AddScriptLPS(1); - if (index < 0) - { - index = src.Length + index; - } - if (index >= src.Length) - { - return 0; - } - try - { - return Convert.ToInt32(src.Data[index]); - } - catch (FormatException) - { - return 0; - } - } - - public double osList2Double(LSL_Types.list src, int index) - { - m_host.AddScriptLPS(1); - if (index < 0) - { - index = src.Length + index; - } - if (index >= src.Length) - { - return 0.0; - } - return Convert.ToDouble(src.Data[index]); - } - - public double llList2Float(LSL_Types.list src, int index) - { - m_host.AddScriptLPS(1); - if (index < 0) - { - index = src.Length + index; - } - if (index >= src.Length) - { - return 0.0; - } - try - { - return Convert.ToDouble(src.Data[index]); - } - catch (FormatException) - { - return 0.0; - } - } - - public string llList2String(LSL_Types.list src, int index) - { - m_host.AddScriptLPS(1); - if (index < 0) - { - index = src.Length + index; - } - if (index >= src.Length) - { - return String.Empty; - } - return src.Data[index].ToString(); - } - - public string llList2Key(LSL_Types.list src, int index) - { - m_host.AddScriptLPS(1); - if (index < 0) - { - index = src.Length + index; - } - if (index >= src.Length) - { - return ""; - } - return src.Data[index].ToString(); - } - - public LSL_Types.Vector3 llList2Vector(LSL_Types.list src, int index) - { - m_host.AddScriptLPS(1); - if (index < 0) - { - index = src.Length + index; - } - if (index >= src.Length) - { - return new LSL_Types.Vector3(0, 0, 0); - } - if (src.Data[index].GetType() == typeof(LSL_Types.Vector3)) - { - return (LSL_Types.Vector3)src.Data[index]; - } - else - { - return new LSL_Types.Vector3(src.Data[index].ToString()); - } - } - - public LSL_Types.Quaternion llList2Rot(LSL_Types.list src, int index) - { - m_host.AddScriptLPS(1); - if (index < 0) - { - index = src.Length + index; - } - if (index >= src.Length) - { - return new LSL_Types.Quaternion(0, 0, 0, 1); - } - if (src.Data[index].GetType() == typeof(LSL_Types.Quaternion)) - { - return (LSL_Types.Quaternion)src.Data[index]; - } - else - { - return new LSL_Types.Quaternion(src.Data[index].ToString()); - } - } - - public LSL_Types.list llList2List(LSL_Types.list src, int start, int end) - { - m_host.AddScriptLPS(1); - return src.GetSublist(start, end); - } - - public LSL_Types.list llDeleteSubList(LSL_Types.list src, int start, int end) - { - return src.DeleteSublist(end, start); - } - - public LSL_Types.LSLInteger llGetListEntryType(LSL_Types.list src, int index) - { - m_host.AddScriptLPS(1); - if (index < 0) - { - index = src.Length + index; - } - if (index >= src.Length) - { - return 0; - } - - if (src.Data[index] is Int32) - return 1; - if (src.Data[index] is Double) - return 2; - if (src.Data[index] is String) - { - LLUUID tuuid; - if (LLUUID.TryParse(src.Data[index].ToString(), out tuuid)) - { - return 3; - } - else - { - return 4; - } - } - if (src.Data[index] is LSL_Types.Vector3) - return 5; - if (src.Data[index] is LSL_Types.Quaternion) - return 6; - if (src.Data[index] is LSL_Types.list) - return 7; - return 0; - - } - - /// - /// Process the supplied list and return the - /// content of the list formatted as a comma - /// separated list. There is a space after - /// each comma. - /// - - public string llList2CSV(LSL_Types.list src) - { - - string ret = String.Empty; - int x = 0; - - m_host.AddScriptLPS(1); - - if (src.Data.Length > 0) - { - ret = src.Data[x++].ToString(); - for (; x < src.Data.Length; x++) - { - ret += ", "+src.Data[x].ToString(); - } - } - - return ret; - } - - /// - /// The supplied string is scanned for commas - /// and converted into a list. Commas are only - /// effective if they are encountered outside - /// of '<' '>' delimiters. Any whitespace - /// before or after an element is trimmed. - /// - - public LSL_Types.list llCSV2List(string src) - { - - LSL_Types.list result = new LSL_Types.list(); - int parens = 0; - int start = 0; - int length = 0; - - m_host.AddScriptLPS(1); - - for (int i = 0; i < src.Length; i++) - { - switch (src[i]) - { - case '<': - parens++; - length++; - break; - case '>': - if (parens > 0) - parens--; - length++; - break; - case ',': - if (parens == 0) - { - result.Add(src.Substring(start,length).Trim()); - start += length+1; - length = 0; - } - else - { - length++; - } - break; - default: - length++; - break; - } - } - - result.Add(src.Substring(start,length).Trim()); - - return result; - } - - /// - /// Randomizes the list, be arbitrarily reordering - /// sublists of stride elements. As the stride approaches - /// the size of the list, the options become very - /// limited. - /// - /// - /// This could take a while for very large list - /// sizes. - /// - - public LSL_Types.list llListRandomize(LSL_Types.list src, int stride) - { - - LSL_Types.list result; - Random rand = new Random(); - - int chunkk; - int[] chunks; - int index1; - int index2; - int tmp; - - m_host.AddScriptLPS(1); - - if (stride == 0) - stride = 1; - - // Stride MUST be a factor of the list length - // If not, then return the src list. This also - // traps those cases where stride > length. - - if (src.Length != stride && src.Length%stride == 0) - { - chunkk = src.Length/stride; - - chunks = new int[chunkk]; - - for (int i = 0; i < chunkk; i++) - chunks[i] = i; - - for (int i = 0; i < chunkk - 1; i++) - { - // randomly select 2 chunks - index1 = rand.Next(rand.Next(65536)); - index1 = index1%chunkk; - index2 = rand.Next(rand.Next(65536)); - index2 = index2%chunkk; - - // and swap their relative positions - tmp = chunks[index1]; - chunks[index1] = chunks[index2]; - chunks[index2] = tmp; - } - - // Construct the randomized list - - result = new LSL_Types.list(); - - for (int i = 0; i < chunkk; i++) - { - for (int j = 0; j < stride; j++) - { - result.Add(src.Data[chunks[i]*stride+j]); - } - } - } - else { - object[] array = new object[src.Length]; - Array.Copy(src.Data, 0, array, 0, src.Length); - result = new LSL_Types.list(array); - } - - return result; - - } - - /// - /// Elements in the source list starting with 0 and then - /// every i+stride. If the stride is negative then the scan - /// is backwards producing an inverted result. - /// Only those elements that are also in the specified - /// range are included in the result. - /// - - public LSL_Types.list llList2ListStrided(LSL_Types.list src, int start, int end, int stride) - { - - LSL_Types.list result = new LSL_Types.list(); - int[] si = new int[2]; - int[] ei = new int[2]; - bool twopass = false; - - m_host.AddScriptLPS(1); - - // First step is always to deal with negative indices - - if (start < 0) - start = src.Length+start; - if (end < 0) - end = src.Length+end; - - // Out of bounds indices are OK, just trim them - // accordingly - - if (start > src.Length) - start = src.Length; - - if (end > src.Length) - end = src.Length; - - // There may be one or two ranges to be considered - - if (start != end) - { - - if (start <= end) - { - si[0] = start; - ei[0] = end; - } - else - { - si[1] = start; - ei[1] = src.Length; - si[0] = 0; - ei[0] = end; - twopass = true; - } - - // The scan always starts from the beginning of the - // source list, but members are only selected if they - // fall within the specified sub-range. The specified - // range values are inclusive. - // A negative stride reverses the direction of the - // scan producing an inverted list as a result. - - if (stride == 0) - stride = 1; - - if (stride > 0) - { - for (int i = 0; i < src.Length; i += stride) - { - if (i<=ei[0] && i>=si[0]) - result.Add(src.Data[i]); - if (twopass && i>=si[1] && i<=ei[1]) - result.Add(src.Data[i]); - } - } - else if (stride < 0) - { - for (int i = src.Length - 1; i >= 0; i += stride) - { - if (i <= ei[0] && i >= si[0]) - result.Add(src.Data[i]); - if (twopass && i >= si[1] && i <= ei[1]) - result.Add(src.Data[i]); - } - } - } - - return result; - } - - public LSL_Types.Vector3 llGetRegionCorner() - { - m_host.AddScriptLPS(1); - return new LSL_Types.Vector3(World.RegionInfo.RegionLocX * Constants.RegionSize, World.RegionInfo.RegionLocY * Constants.RegionSize, 0); - } - - /// - /// Insert the list identified by into the - /// list designated by such that the first - /// new element has the index specified by - /// - - public LSL_Types.list llListInsertList(LSL_Types.list dest, LSL_Types.list src, int index) - { - - LSL_Types.list pref = null; - LSL_Types.list suff = null; - - m_host.AddScriptLPS(1); - - if (index < 0) - { - index = index+dest.Length; - if (index < 0) - { - index = 0; - } - } - - if (index != 0) - { - pref = dest.GetSublist(0,index-1); - if (index < dest.Length) - { - suff = dest.GetSublist(index,-1); - return pref + src + suff; - } - else - { - return pref + src; - } - } - else - { - if (index < dest.Length) - { - suff = dest.GetSublist(index,-1); - return src + suff; - } - else - { - return src; - } - } - - } - - /// - /// Returns the index of the first occurrence of test - /// in src. - /// - - public LSL_Types.LSLInteger llListFindList(LSL_Types.list src, LSL_Types.list test) - { - - int index = -1; - int length = src.Length - test.Length + 1; - - m_host.AddScriptLPS(1); - - // If either list is empty, do not match - - if (src.Length != 0 && test.Length != 0) - { - for (int i = 0; i < length; i++) - { - if (src.Data[i].Equals(test.Data[0])) - { - int j; - for (j = 1; j < test.Length; j++) - if (!src.Data[i+j].Equals(test.Data[j])) - break; - if (j == test.Length) - { - index = i; - break; - } - } - } - } - - return index; - - } - - public string llGetObjectName() - { - m_host.AddScriptLPS(1); - return m_host.Name!=null?m_host.Name:String.Empty; - } - - public void llSetObjectName(string name) - { - m_host.AddScriptLPS(1); - m_host.Name = name!=null?name:String.Empty; - } - - public string llGetDate() - { - m_host.AddScriptLPS(1); - DateTime date = DateTime.Now.ToUniversalTime(); - string result = date.ToString("yyyy-MM-dd"); - return result; - } - - public LSL_Types.LSLInteger llEdgeOfWorld(LSL_Types.Vector3 pos, LSL_Types.Vector3 dir) - { - m_host.AddScriptLPS(1); - NotImplemented("llEdgeOfWorld"); - return 0; - } - - public LSL_Types.LSLInteger llGetAgentInfo(string id) - { - m_host.AddScriptLPS(1); - NotImplemented("llGetAgentInfo"); - return 0; - } - - public void llAdjustSoundVolume(double volume) - { - m_host.AddScriptLPS(1); - m_host.AdjustSoundGain(volume); - } - - public void llSetSoundQueueing(int queue) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetSoundQueueing"); - } - - public void llSetSoundRadius(double radius) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetSoundRadius"); - } - - public string llKey2Name(string id) - { - m_host.AddScriptLPS(1); - LLUUID key = new LLUUID(); - if (LLUUID.TryParse(id,out key)) - { - ScenePresence presence = World.GetScenePresence(key); - - if (presence != null) - { - return presence.ControllingClient.Name; - //return presence.Name; - } - - if (World.GetSceneObjectPart(key) != null) - { - return World.GetSceneObjectPart(key).Name; - } - } - return String.Empty; - } - - - - public void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate) - { - m_host.AddScriptLPS(1); - Primitive.TextureAnimation pTexAnim = new Primitive.TextureAnimation(); - pTexAnim.Flags =(uint) mode; - - //ALL_SIDES - if (face == -1) - face = 255; - - pTexAnim.Face = (uint)face; - pTexAnim.Length = (float)length; - pTexAnim.Rate = (float)rate; - pTexAnim.SizeX = (uint)sizex; - pTexAnim.SizeY = (uint)sizey; - pTexAnim.Start = (float)start; - - m_host.AddTextureAnimation(pTexAnim); - m_host.SendFullUpdateToAllClients(); - } - - public void llTriggerSoundLimited(string sound, double volume, LSL_Types.Vector3 top_north_east, - LSL_Types.Vector3 bottom_south_west) - { - m_host.AddScriptLPS(1); - NotImplemented("llTriggerSoundLimited"); - } - - public void llEjectFromLand(string pest) - { - m_host.AddScriptLPS(1); - NotImplemented("llEjectFromLand"); - } - - public LSL_Types.list llParseString2List(string str, LSL_Types.list separators, LSL_Types.list spacers) - { - m_host.AddScriptLPS(1); - LSL_Types.list ret = new LSL_Types.list(); - object[] delimiters = new object[separators.Length + spacers.Length]; - separators.Data.CopyTo(delimiters, 0); - spacers.Data.CopyTo(delimiters, separators.Length); - bool dfound = false; - do - { - dfound = false; - int cindex = -1; - string cdeli = ""; - for (int i = 0; i < delimiters.Length; i++) - { - int index = str.IndexOf(delimiters[i].ToString()); - bool found = index != -1; - if (found) - { - if ((cindex > index) || (cindex == -1)) - { - cindex = index; - cdeli = (string)delimiters[i]; - } - dfound = dfound || found; - } - } - if (cindex != -1) - { - if (cindex > 0) - { - ret.Add(str.Substring(0, cindex)); - if (spacers.Contains(cdeli)) - { - ret.Add(cdeli); - } - } - if (cindex == 0 && spacers.Contains(cdeli)) - { - ret.Add(cdeli); - } - str = str.Substring(cindex + cdeli.Length); - } - } while (dfound); - if (str != "") - { - ret.Add(str); - } - return ret; - } - - public LSL_Types.LSLInteger llOverMyLand(string id) - { - - m_host.AddScriptLPS(1); - LLUUID key = new LLUUID(); - if (LLUUID.TryParse(id,out key)) - { - SceneObjectPart obj = new SceneObjectPart(); - obj = World.GetSceneObjectPart(World.Entities[key].LocalId); - if (obj.OwnerID == World.GetLandOwner(obj.AbsolutePosition.X, obj.AbsolutePosition.Y)) - { - return 1; - } - else - { - return 0; - } - } - else - { - return 0; - } - } - - public string llGetLandOwnerAt(LSL_Types.Vector3 pos) - { - m_host.AddScriptLPS(1); - return World.GetLandOwner((float)pos.x, (float)pos.y).ToString(); - } - - public LSL_Types.Vector3 llGetAgentSize(string id) - { - m_host.AddScriptLPS(1); - NotImplemented("llGetAgentSize"); - return new LSL_Types.Vector3(); - } - - public LSL_Types.LSLInteger llSameGroup(string agent) - { - m_host.AddScriptLPS(1); - NotImplemented("llSameGroup"); - return 0; - } - - public void llUnSit(string id) - { - m_host.AddScriptLPS(1); - - LLUUID key = new LLUUID(); - if (LLUUID.TryParse(id, out key)) - { - ScenePresence av = World.GetScenePresence(key); - - if (av != null) - { - if (llAvatarOnSitTarget() == id) - { - // if the avatar is sitting on this object, then - // we can unsit them. We don't want random scripts unsitting random people - // Lets avoid the popcorn avatar scenario. - av.StandUp(); - } - else - { - // If the object owner also owns the parcel - // or - // if the land is group owned and the object is group owned by the same group - // or - // if the object is owned by a person with estate access. - - ILandObject parcel = World.LandChannel.GetLandObject(av.AbsolutePosition.X, av.AbsolutePosition.Y); - if (parcel != null) - { - if (m_host.ObjectOwner == parcel.landData.ownerID || - (m_host.OwnerID == m_host.GroupID && m_host.GroupID == parcel.landData.groupID - && parcel.landData.isGroupOwned) || World.ExternalChecks.ExternalChecksCanBeGodLike(m_host.OwnerID)) - { - av.StandUp(); - } - } - } - } - - } - - } - - public LSL_Types.Vector3 llGroundSlope(LSL_Types.Vector3 offset) - { - m_host.AddScriptLPS(1); - NotImplemented("llGroundSlope"); - return new LSL_Types.Vector3(); - } - - public LSL_Types.Vector3 llGroundNormal(LSL_Types.Vector3 offset) - { - m_host.AddScriptLPS(1); - NotImplemented("llGroundNormal"); - return new LSL_Types.Vector3(); - } - - public LSL_Types.Vector3 llGroundContour(LSL_Types.Vector3 offset) - { - m_host.AddScriptLPS(1); - NotImplemented("llGroundContour"); - return new LSL_Types.Vector3(); - } - - public LSL_Types.LSLInteger llGetAttached() - { - m_host.AddScriptLPS(1); - NotImplemented("llGetAttached"); - return 0; - } - - public LSL_Types.LSLInteger llGetFreeMemory() - { - m_host.AddScriptLPS(1); - NotImplemented("llGetFreeMemory"); - return 0; - } - - public string llGetRegionName() - { - m_host.AddScriptLPS(1); - return World.RegionInfo.RegionName; - } - - public double llGetRegionTimeDilation() - { - m_host.AddScriptLPS(1); - return (double)World.TimeDilation; - } - - public double llGetRegionFPS() - { - m_host.AddScriptLPS(1); - //TODO: return actual FPS - return 10.0f; - } - - /* particle system rules should be coming into this routine as doubles, that is - rule[0] should be an integer from this list and rule[1] should be the arg - for the same integer. wiki.secondlife.com has most of this mapping, but some - came from http://www.caligari-designs.com/p4u2 - - We iterate through the list for 'Count' elements, incrementing by two for each - iteration and set the members of Primitive.ParticleSystem, one at a time. - */ - - public enum PrimitiveRule : int - { - PSYS_PART_FLAGS = 0, - PSYS_PART_START_COLOR = 1, - PSYS_PART_START_ALPHA = 2, - PSYS_PART_END_COLOR = 3, - PSYS_PART_END_ALPHA = 4, - PSYS_PART_START_SCALE = 5, - PSYS_PART_END_SCALE = 6, - PSYS_PART_MAX_AGE = 7, - PSYS_SRC_ACCEL = 8, - PSYS_SRC_PATTERN = 9, - PSYS_SRC_TEXTURE = 12, - PSYS_SRC_BURST_RATE = 13, - PSYS_SRC_BURST_PART_COUNT = 15, - PSYS_SRC_BURST_RADIUS = 16, - PSYS_SRC_BURST_SPEED_MIN = 17, - PSYS_SRC_BURST_SPEED_MAX = 18, - PSYS_SRC_MAX_AGE = 19, - PSYS_SRC_TARGET_KEY = 20, - PSYS_SRC_OMEGA = 21, - PSYS_SRC_ANGLE_BEGIN = 22, - PSYS_SRC_ANGLE_END = 23 - } - - internal Primitive.ParticleSystem.ParticleDataFlags ConvertUINTtoFlags(uint flags) - { - Primitive.ParticleSystem.ParticleDataFlags returnval = Primitive.ParticleSystem.ParticleDataFlags.None; - - return returnval; - } - - - public void llParticleSystem(LSL_Types.list rules) - { - m_host.AddScriptLPS(1); - Primitive.ParticleSystem prules = new Primitive.ParticleSystem(); - LSL_Types.Vector3 tempv = new LSL_Types.Vector3(); - - float tempf = 0; - - for (int i = 0; i < rules.Length; i += 2) - { - switch ((int)rules.Data[i]) - { - case (int)BuiltIn_Commands_BaseClass.PSYS_PART_FLAGS: - prules.PartDataFlags = (Primitive.ParticleSystem.ParticleDataFlags)((uint)Convert.ToInt32(rules.Data[i + 1].ToString())); - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_PART_START_COLOR: - tempv = (LSL_Types.Vector3)rules.Data[i + 1]; - prules.PartStartColor.R = (float)tempv.x; - prules.PartStartColor.G = (float)tempv.y; - prules.PartStartColor.B = (float)tempv.z; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_PART_START_ALPHA: - tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); - prules.PartStartColor.A = (float)tempf; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_PART_END_COLOR: - tempv = (LSL_Types.Vector3)rules.Data[i + 1]; - //prules.PartEndColor = new LLColor(tempv.x,tempv.y,tempv.z,1); - - prules.PartEndColor.R = (float)tempv.x; - prules.PartEndColor.G = (float)tempv.y; - prules.PartEndColor.B = (float)tempv.z; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_PART_END_ALPHA: - tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); - prules.PartEndColor.A = (float)tempf; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_PART_START_SCALE: - tempv = (LSL_Types.Vector3)rules.Data[i + 1]; - prules.PartStartScaleX = (float)tempv.x; - prules.PartStartScaleY = (float)tempv.y; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_PART_END_SCALE: - tempv = (LSL_Types.Vector3)rules.Data[i + 1]; - prules.PartEndScaleX = (float)tempv.x; - prules.PartEndScaleY = (float)tempv.y; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_PART_MAX_AGE: - tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); - prules.PartMaxAge = (float)tempf; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_ACCEL: - tempv = (LSL_Types.Vector3)rules.Data[i + 1]; - prules.PartAcceleration.X = (float)tempv.x; - prules.PartAcceleration.Y = (float)tempv.y; - prules.PartAcceleration.Z = (float)tempv.z; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_PATTERN: - int tmpi = int.Parse(rules.Data[i + 1].ToString()); - prules.Pattern = (Primitive.ParticleSystem.SourcePattern)tmpi; - break; - - // Xantor 20080503 - // Wiki: PSYS_SRC_TEXTURE string inventory item name or key of the particle texture - // "" = default texture. - // 20080530 Updated to remove code duplication - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_TEXTURE: - prules.Texture = KeyOrName(rules.Data[i + 1].ToString()); - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_BURST_RATE: - tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); - prules.BurstRate = (float)tempf; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_BURST_PART_COUNT: - prules.BurstPartCount = (byte)Convert.ToByte(rules.Data[i + 1].ToString()); - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_BURST_RADIUS: - tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); - prules.BurstRadius = (float)tempf; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_BURST_SPEED_MIN: - tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); - prules.BurstSpeedMin = (float)tempf; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_BURST_SPEED_MAX: - tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); - prules.BurstSpeedMax = (float)tempf; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_MAX_AGE: - tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); - prules.MaxAge = (float)tempf; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_TARGET_KEY: - LLUUID key = LLUUID.Zero; - if (LLUUID.TryParse(rules.Data[i + 1].ToString(), out key)) - { - prules.Target = key; - } - else - { - prules.Target = m_host.UUID; - } - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_OMEGA: - // AL: This is an assumption, since it is the only thing that would match. - tempv = (LSL_Types.Vector3)rules.Data[i + 1]; - prules.AngularVelocity.X = (float)tempv.x; - prules.AngularVelocity.Y = (float)tempv.y; - prules.AngularVelocity.Z = (float)tempv.z; - //cast?? prules.MaxAge = (float)rules[i + 1]; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_ANGLE_BEGIN: - tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); - prules.InnerAngle = (float)tempf; - break; - - case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_ANGLE_END: - tempf = Convert.ToSingle(rules.Data[i + 1].ToString()); - prules.OuterAngle = (float)tempf; - break; - } - - } - prules.CRC = 1; - - m_host.AddNewParticleSystem(prules); - m_host.SendFullUpdateToAllClients(); - } - - public void llGroundRepel(double height, int water, double tau) - { - m_host.AddScriptLPS(1); - NotImplemented("llGroundRepel"); - } - - public void llGiveInventoryList(string destination, string category, LSL_Types.list inventory) - { - m_host.AddScriptLPS(1); - NotImplemented("llGiveInventoryList"); - } - - public void llSetVehicleType(int type) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetVehicleType"); - } - - public void llSetVehicledoubleParam(int param, double value) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetVehicledoubleParam"); - } - - public void llSetVehicleFloatParam(int param, float value) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetVehicleFloatParam"); - } - - public void llSetVehicleVectorParam(int param, LSL_Types.Vector3 vec) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetVehicleVectorParam"); - } - - public void llSetVehicleRotationParam(int param, LSL_Types.Quaternion rot) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetVehicleRotationParam"); - } - - public void llSetVehicleFlags(int flags) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetVehicleFlags"); - } - - public void llRemoveVehicleFlags(int flags) - { - m_host.AddScriptLPS(1); - NotImplemented("llRemoveVehicleFlags"); - } - - public void llSitTarget(LSL_Types.Vector3 offset, LSL_Types.Quaternion rot) - { - m_host.AddScriptLPS(1); - // LSL quaternions can normalize to 0, normal Quaternions can't. - if (rot.s == 0 && rot.x == 0 && rot.y == 0 && rot.z == 0) - rot.z = 1; // ZERO_ROTATION = 0,0,0,1 - - m_host.SetSitTarget(new Vector3((float)offset.x, (float)offset.y, (float)offset.z), new Quaternion((float)rot.s, (float)rot.x, (float)rot.y, (float)rot.z)); - } - - public string llAvatarOnSitTarget() - { - m_host.AddScriptLPS(1); - return m_host.GetAvatarOnSitTarget().ToString(); - } - - public void llAddToLandPassList(string avatar, double hours) - { - m_host.AddScriptLPS(1); - LLUUID key; - LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData; - if (land.ownerID == m_host.OwnerID) - { - ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry(); - if (LLUUID.TryParse(avatar, out key)) - { - entry.AgentID = key; - entry.Flags = ParcelManager.AccessList.Access; - entry.Time = DateTime.Now.AddHours(hours); - land.parcelAccessList.Add(entry); - } - } - } - - public void llSetTouchText(string text) - { - m_host.AddScriptLPS(1); - m_host.TouchName = text; - } - - public void llSetSitText(string text) - { - m_host.AddScriptLPS(1); - m_host.SitName = text; - } - - public void llSetCameraEyeOffset(LSL_Types.Vector3 offset) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetCameraEyeOffset"); - } - - public void llSetCameraAtOffset(LSL_Types.Vector3 offset) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetCameraAtOffset"); - } - - public string llDumpList2String(LSL_Types.list src, string seperator) - { - m_host.AddScriptLPS(1); - if (src.Length == 0) - { - return String.Empty; - } - string ret = String.Empty; - foreach (object o in src.Data) - { - ret = ret + o.ToString() + seperator; - } - ret = ret.Substring(0, ret.Length - seperator.Length); - return ret; - } - - public LSL_Types.LSLInteger llScriptDanger(LSL_Types.Vector3 pos) - { - m_host.AddScriptLPS(1); - bool result = World.scriptDanger(m_host.LocalId, new LLVector3((float)pos.x, (float)pos.y, (float)pos.z)); - if (result) - { - return 1; - } - else - { - return 0; - } - - } - - public void llDialog(string avatar, string message, LSL_Types.list buttons, int chat_channel) - { - m_host.AddScriptLPS(1); - LLUUID av = new LLUUID(); - if (!LLUUID.TryParse(avatar,out av)) - { - LSLError("First parameter to llDialog needs to be a key"); - return; - } - if (buttons.Length > 12) - { - LSLError("No more than 12 buttons can be shown"); - return; - } - string[] buts = new string[buttons.Length]; - for (int i = 0; i < buttons.Length; i++) - { - if (buttons.Data[i].ToString() == String.Empty) - { - LSLError("button label cannot be blank"); - return; - } - if (buttons.Data[i].ToString().Length > 24) - { - LSLError("button label cannot be longer than 24 characters"); - return; - } - buts[i] = buttons.Data[i].ToString(); - } - World.SendDialogToUser(av, m_host.Name, m_host.UUID, m_host.OwnerID, message, new LLUUID("00000000-0000-2222-3333-100000001000"), chat_channel, buts); - } - - public void llVolumeDetect(int detect) - { - m_host.AddScriptLPS(1); - NotImplemented("llVolumeDetect"); - } - - /// - /// Reset the named script. The script must be present - /// in the same prim. - /// - - public void llResetOtherScript(string name) - { - LLUUID item; - - m_host.AddScriptLPS(1); - - if ((item = ScriptByName(name)) != LLUUID.Zero) - m_ScriptEngine.ResetScript(item); - else - ShoutError("llResetOtherScript: script "+name+" not found"); - } - - public LSL_Types.LSLInteger llGetScriptState(string name) - { - LLUUID item; - - m_host.AddScriptLPS(1); - - if ((item = ScriptByName(name)) != LLUUID.Zero) - { - return m_ScriptEngine.GetScriptState(item) ?1:0; - } - - ShoutError("llGetScriptState: script "+name+" not found"); - - // If we didn't find it, then it's safe to - // assume it is not running. - - return 0; - } - - public void llRemoteLoadScript() - { - m_host.AddScriptLPS(1); - Deprecated("llRemoteLoadScript"); - } - - public void llSetRemoteScriptAccessPin(int pin) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetRemoteScriptAccessPin"); - } - - public void llRemoteLoadScriptPin(string target, string name, int pin, int running, int start_param) - { - m_host.AddScriptLPS(1); - NotImplemented("llRemoteLoadScriptPin"); - } - - // remote_data(integer type, key channel, key message_id, string sender, integer ival, string sval) - // Not sure where these constants should live: - // REMOTE_DATA_CHANNEL = 1 - // REMOTE_DATA_REQUEST = 2 - // REMOTE_DATA_REPLY = 3 - public void llOpenRemoteDataChannel() - { - m_host.AddScriptLPS(1); - IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface(); - if (xmlrpcMod.IsEnabled()) - { - LLUUID channelID = xmlrpcMod.OpenXMLRPCChannel(m_localID, m_itemID, LLUUID.Zero); - object[] resobj = new object[] { new LSL_Types.LSLInteger(1), new LSL_Types.LSLString(channelID.ToString()), new LSL_Types.LSLString(LLUUID.Zero.ToString()), new LSL_Types.LSLString(String.Empty), new LSL_Types.LSLInteger(0), new LSL_Types.LSLString(String.Empty) }; - m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams( - "remote_data", resobj, - new XDetectParams[0])); - } - } - - public string llSendRemoteData(string channel, string dest, int idata, string sdata) - { - m_host.AddScriptLPS(1); - IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface(); - return (xmlrpcMod.SendRemoteData(m_localID, m_itemID, channel, dest, idata, sdata)).ToString(); - } - - public void llRemoteDataReply(string channel, string message_id, string sdata, int idata) - { - m_host.AddScriptLPS(1); - IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface(); - xmlrpcMod.RemoteDataReply(channel, message_id, sdata, idata); - } - - public void llCloseRemoteDataChannel(string channel) - { - m_host.AddScriptLPS(1); - IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface(); - xmlrpcMod.CloseXMLRPCChannel(channel); - } - - public string llMD5String(string src, int nonce) - { - m_host.AddScriptLPS(1); - return Util.Md5Hash(src + ":" + nonce.ToString()); - } - - public void llSetPrimitiveParams(LSL_Types.list rules) - { - llSetLinkPrimitiveParams(m_host.LinkNum+1, rules); - } - - public void llSetLinkPrimitiveParams(int linknumber, LSL_Types.list rules) - { - m_host.AddScriptLPS(1); - - SceneObjectPart part=null; - - if (m_host.LinkNum+1 != linknumber) - { - foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts()) - { - if ((partInst.LinkNum + 1) == linknumber) - { - part = partInst; - break; - } - } - } - else - { - part = m_host; - } - - if (part == null) - return; - - int idx = 0; - - while (idx < rules.Length) - { - int code = Convert.ToInt32(rules.Data[idx++]); - - int remain = rules.Length - idx; - - int face; - LSL_Types.Vector3 v; - - switch (code) - { - case 6: // PRIM_POSITION - if (remain < 1) - return; - - v=new LSL_Types.Vector3(rules.Data[idx++].ToString()); - SetPos(part, v); - - break; - case 7: // PRIM_SIZE - if (remain < 1) - return; - - v=new LSL_Types.Vector3(rules.Data[idx++].ToString()); - SetScale(part, v); - - break; - case 8: // PRIM_ROTATION - if (remain < 1) - return; - - LSL_Types.Quaternion q = new LSL_Types.Quaternion(rules.Data[idx++].ToString()); - SetRot(part, q); - - break; - - case 17: // PRIM_TEXTURE - if (remain < 5) - return; - - face=Convert.ToInt32(rules.Data[idx++]); - string tex=rules.Data[idx++].ToString(); - LSL_Types.Vector3 repeats=new LSL_Types.Vector3(rules.Data[idx++].ToString()); - LSL_Types.Vector3 offsets=new LSL_Types.Vector3(rules.Data[idx++].ToString()); - double rotation=Convert.ToDouble(rules.Data[idx++]); - - SetTexture(part, tex, face); - ScaleTexture(part, repeats.x, repeats.y, face); - OffsetTexture(part, offsets.x, offsets.y, face); - RotateTexture(part, rotation, face); - - break; - - case 18: // PRIM_COLOR - if (remain < 3) - return; - - face=Convert.ToInt32(rules.Data[idx++]); - LSL_Types.Vector3 color=new LSL_Types.Vector3(rules.Data[idx++].ToString()); - double alpha=Convert.ToDouble(rules.Data[idx++]); - - SetColor(part, color, face); - SetAlpha(part, alpha, face); - - break; - case 21: // PRIM_FLEXI - if (remain < 7) - return; - - int flexi = Convert.ToInt32(rules.Data[idx++]); - int softness = Convert.ToInt32(rules.Data[idx++]); - float gravity = (float)Convert.ToDouble(rules.Data[idx++]); - float friction = (float)Convert.ToDouble(rules.Data[idx++]); - float wind = (float)Convert.ToDouble(rules.Data[idx++]); - float tension = (float)Convert.ToDouble(rules.Data[idx++]); - LSL_Types.Vector3 force =new LSL_Types.Vector3(rules.Data[idx++].ToString()); - - SetFlexi(part, (flexi == 1), softness, gravity, friction, wind, tension, force); - - break; - case 23: // PRIM_POINT_LIGHT - if (remain < 5) - return; - int light = Convert.ToInt32(rules.Data[idx++]); - LSL_Types.Vector3 lightcolor =new LSL_Types.Vector3(rules.Data[idx++].ToString()); - float intensity = (float)Convert.ToDouble(rules.Data[idx++]); - float radius = (float)Convert.ToDouble(rules.Data[idx++]); - float falloff = (float)Convert.ToDouble(rules.Data[idx++]); - - SetPointLight(part, (light == 1), lightcolor, intensity, radius, falloff); - - break; - } - } - } - - public string llStringToBase64(string str) - { - m_host.AddScriptLPS(1); - try - { - byte[] encData_byte = new byte[str.Length]; - encData_byte = Encoding.UTF8.GetBytes(str); - string encodedData = Convert.ToBase64String(encData_byte); - return encodedData; - } - catch (Exception e) - { - throw new Exception("Error in base64Encode" + e.Message); - } - } - - public string llBase64ToString(string str) - { - m_host.AddScriptLPS(1); - UTF8Encoding encoder = new UTF8Encoding(); - Decoder utf8Decode = encoder.GetDecoder(); - try - { - byte[] todecode_byte = Convert.FromBase64String(str); - int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length); - char[] decoded_char = new char[charCount]; - utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0); - string result = new String(decoded_char); - return result; - } - catch (Exception e) - { - throw new Exception("Error in base64Decode" + e.Message); - } - } - - public void llXorBase64Strings() - { - m_host.AddScriptLPS(1); - Deprecated("llXorBase64Strings"); - } - - public void llRemoteDataSetRegion() - { - m_host.AddScriptLPS(1); - NotImplemented("llRemoteDataSetRegion"); - } - - public double llLog10(double val) - { - m_host.AddScriptLPS(1); - return (double)Math.Log10(val); - } - - public double llLog(double val) - { - m_host.AddScriptLPS(1); - return (double)Math.Log(val); - } - - public LSL_Types.list llGetAnimationList(string id) - { - m_host.AddScriptLPS(1); - NotImplemented("llGetAnimationList"); - return new LSL_Types.list(); - } - - public void llSetParcelMusicURL(string url) - { - m_host.AddScriptLPS(1); - LLUUID landowner = World.GetLandOwner(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y); - if (landowner == LLUUID.Zero) - { - return; - } - if (landowner != m_host.ObjectOwner) - { - return; - } - World.SetLandMusicURL(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, url); - } - - public void osSetParcelMediaURL(string url) - { - m_host.AddScriptLPS(1); - LLUUID landowner = World.GetLandOwner(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y); - - if (landowner == LLUUID.Zero) - { - return; - } - - if (landowner != m_host.ObjectOwner) - { - return; - } - - World.SetLandMediaURL(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, url); - } - - public LSL_Types.Vector3 llGetRootPosition() - { - m_host.AddScriptLPS(1); - return new LSL_Types.Vector3(m_host.ParentGroup.AbsolutePosition.X, m_host.ParentGroup.AbsolutePosition.Y, m_host.ParentGroup.AbsolutePosition.Z); - } - - public LSL_Types.Quaternion llGetRootRotation() - { - m_host.AddScriptLPS(1); - return new LSL_Types.Quaternion(m_host.ParentGroup.GroupRotation.X, m_host.ParentGroup.GroupRotation.Y, m_host.ParentGroup.GroupRotation.Z, m_host.ParentGroup.GroupRotation.W); - } - - public string llGetObjectDesc() - { - return m_host.Description!=null?m_host.Description:String.Empty; - } - - public void llSetObjectDesc(string desc) - { - m_host.AddScriptLPS(1); - m_host.Description = desc!=null?desc:String.Empty; - } - - public string llGetCreator() - { - m_host.AddScriptLPS(1); - return m_host.ObjectCreator.ToString(); - } - - public string llGetTimestamp() - { - m_host.AddScriptLPS(1); - return DateTime.Now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.fffffffZ"); - } - - public void llSetLinkAlpha(int linknumber, double alpha, int face) - { - m_host.AddScriptLPS(1); - SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknumber); - if (linknumber > -1) - { - LLObject.TextureEntry tex = part.Shape.Textures; - LLColor texcolor; - if (face > -1) - { - texcolor = tex.CreateFace((uint)face).RGBA; - texcolor.A = (float)Math.Abs(alpha - 1); - tex.FaceTextures[face].RGBA = texcolor; - part.UpdateTexture(tex); - return; - } - else if (face == -1) - { - texcolor = tex.DefaultTexture.RGBA; - texcolor.A = (float)Math.Abs(alpha - 1); - tex.DefaultTexture.RGBA = texcolor; - for (uint i = 0; i < 32; i++) - { - if (tex.FaceTextures[i] != null) - { - texcolor = tex.FaceTextures[i].RGBA; - texcolor.A = (float)Math.Abs(alpha - 1); - tex.FaceTextures[i].RGBA = texcolor; - } - } - texcolor = tex.DefaultTexture.RGBA; - texcolor.A = (float)Math.Abs(alpha - 1); - tex.DefaultTexture.RGBA = texcolor; - part.UpdateTexture(tex); - return; - } - return; - } - else if (linknumber == -1) - { - int num = m_host.ParentGroup.PrimCount; - for (int w = 0; w < num; w++) - { - linknumber = w; - part = m_host.ParentGroup.GetLinkNumPart(linknumber); - LLObject.TextureEntry tex = part.Shape.Textures; - LLColor texcolor; - if (face > -1) - { - texcolor = tex.CreateFace((uint)face).RGBA; - texcolor.A = (float)Math.Abs(alpha - 1); - tex.FaceTextures[face].RGBA = texcolor; - part.UpdateTexture(tex); - } - else if (face == -1) - { - texcolor = tex.DefaultTexture.RGBA; - texcolor.A = (float)Math.Abs(alpha - 1); - tex.DefaultTexture.RGBA = texcolor; - for (uint i = 0; i < 32; i++) - { - if (tex.FaceTextures[i] != null) - { - texcolor = tex.FaceTextures[i].RGBA; - texcolor.A = (float)Math.Abs(alpha - 1); - tex.FaceTextures[i].RGBA = texcolor; - } - } - texcolor = tex.DefaultTexture.RGBA; - texcolor.A = (float)Math.Abs(alpha - 1); - tex.DefaultTexture.RGBA = texcolor; - part.UpdateTexture(tex); - } - } - return; - } - } - - public LSL_Types.LSLInteger llGetNumberOfPrims() - { - m_host.AddScriptLPS(1); - return m_host.ParentGroup.PrimCount; - } - - public LSL_Types.list llGetBoundingBox(string obj) - { - m_host.AddScriptLPS(1); - NotImplemented("llGetBoundingBox"); - return new LSL_Types.list(); - } - - public LSL_Types.Vector3 llGetGeometricCenter() - { - return new LSL_Types.Vector3(m_host.GetGeometricCenter().X, m_host.GetGeometricCenter().Y, m_host.GetGeometricCenter().Z); - } - - public LSL_Types.list llGetPrimitiveParams(LSL_Types.list rules) - { - m_host.AddScriptLPS(1); - - LSL_Types.list res = new LSL_Types.list(); - int idx=0; - while (idx < rules.Length) - { - int code=Convert.ToInt32(rules.Data[idx++]); - int remain=rules.Length-idx; - - switch (code) - { - case 2: // PRIM_MATERIAL - res.Add(new LSL_Types.LSLInteger(m_host.Material)); - break; - - case 3: // PRIM_PHYSICS - if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Physics) != 0) - res.Add(new LSL_Types.LSLInteger(1)); - else - res.Add(new LSL_Types.LSLInteger(0)); - break; - - case 4: // PRIM_TEMP_ON_REZ - if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.TemporaryOnRez) != 0) - res.Add(new LSL_Types.LSLInteger(1)); - else - res.Add(new LSL_Types.LSLInteger(0)); - break; - - case 5: // PRIM_PHANTOM - if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Phantom) != 0) - res.Add(new LSL_Types.LSLInteger(1)); - else - res.Add(new LSL_Types.LSLInteger(0)); - break; - - case 6: // PRIM_POSITION - res.Add(new LSL_Types.Vector3(m_host.AbsolutePosition.X, - m_host.AbsolutePosition.Y, - m_host.AbsolutePosition.Z)); - break; - - case 7: // PRIM_SIZE - res.Add(new LSL_Types.Vector3(m_host.Scale.X, - m_host.Scale.Y, - m_host.Scale.Z)); - break; - - case 8: // PRIM_ROTATION - res.Add(new LSL_Types.Quaternion(m_host.RotationOffset.X, - m_host.RotationOffset.Y, - m_host.RotationOffset.Z, - m_host.RotationOffset.W)); - break; - - case 9: // PRIM_TYPE - // TODO-------------- - res.Add(new LSL_Types.LSLInteger(0)); - break; - - case 17: // PRIM_TEXTURE - if (remain < 1) - return res; - - int face=Convert.ToInt32(rules.Data[idx++]); - if (face == -1) - face = 0; - - LLObject.TextureEntry tex = m_host.Shape.Textures; - LLObject.TextureEntryFace texface = tex.GetFace((uint)face); - - res.Add(new LSL_Types.LSLString(texface.TextureID.ToString())); - res.Add(new LSL_Types.Vector3(texface.RepeatU, - texface.RepeatV, - 0)); - res.Add(new LSL_Types.Vector3(texface.OffsetU, - texface.OffsetV, - 0)); - res.Add(new LSL_Types.LSLFloat(texface.Rotation)); - break; - - case 18: // PRIM_COLOR - if (remain < 1) - return res; - - face=Convert.ToInt32(rules.Data[idx++]); - - tex = m_host.Shape.Textures; - LLColor texcolor; - if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color - texcolor = tex.DefaultTexture.RGBA; - else - texcolor = tex.GetFace((uint)face).RGBA; - res.Add(new LSL_Types.Vector3((255 - (texcolor.R * 255)) / 255, - (255 - (texcolor.G * 255)) / 255, - (255 - (texcolor.B * 255)) / 255)); - res.Add(new LSL_Types.LSLFloat((texcolor.A * 255) / 255)); - break; - - case 19: // PRIM_BUMP_SHINY - // TODO-------------- - if (remain < 1) - return res; - - face=Convert.ToInt32(rules.Data[idx++]); - - res.Add(new LSL_Types.LSLInteger(0)); - res.Add(new LSL_Types.LSLInteger(0)); - break; - - case 20: // PRIM_FULLBRIGHT - // TODO-------------- - if (remain < 1) - return res; - - face=Convert.ToInt32(rules.Data[idx++]); - - res.Add(new LSL_Types.LSLInteger(0)); - break; - - case 21: // PRIM_FLEXIBLE - PrimitiveBaseShape shape = m_host.Shape; - - if (shape.FlexiEntry) - res.Add(new LSL_Types.LSLInteger(1)); // active - else - res.Add(new LSL_Types.LSLInteger(0)); - res.Add(new LSL_Types.LSLInteger(shape.FlexiSoftness));// softness - res.Add(new LSL_Types.LSLFloat(shape.FlexiGravity)); // gravity - res.Add(new LSL_Types.LSLFloat(shape.FlexiDrag)); // friction - res.Add(new LSL_Types.LSLFloat(shape.FlexiWind)); // wind - res.Add(new LSL_Types.LSLFloat(shape.FlexiTension)); // tension - res.Add(new LSL_Types.Vector3(shape.FlexiForceX, // force - shape.FlexiForceY, - shape.FlexiForceZ)); - break; - - case 22: // PRIM_TEXGEN - // TODO-------------- - // (PRIM_TEXGEN_DEFAULT, PRIM_TEXGEN_PLANAR) - if (remain < 1) - return res; - - face=Convert.ToInt32(rules.Data[idx++]); - - res.Add(new LSL_Types.LSLInteger(0)); - break; - - case 23: // PRIM_POINT_LIGHT: - shape = m_host.Shape; - - if (shape.LightEntry) - res.Add(new LSL_Types.LSLInteger(1)); // active - else - res.Add(new LSL_Types.LSLInteger(0)); - res.Add(new LSL_Types.Vector3(shape.LightColorR, // color - shape.LightColorG, - shape.LightColorB)); - res.Add(new LSL_Types.LSLFloat(shape.LightIntensity)); // intensity - res.Add(new LSL_Types.LSLFloat(shape.LightRadius)); // radius - res.Add(new LSL_Types.LSLFloat(shape.LightFalloff)); // falloff - break; - - case 24: // PRIM_GLOW - // TODO-------------- - if (remain < 1) - return res; - - face=Convert.ToInt32(rules.Data[idx++]); - - res.Add(new LSL_Types.LSLFloat(0)); - break; - } - } - return res; - } - - // - // - // The .NET definition of base 64 is: - // - // - // Significant: A-Z a-z 0-9 + - - // - // - // Whitespace: \t \n \r ' ' - // - // - // Valueless: = - // - // - // End-of-string: \0 or '==' - // - // - // - // - // Each point in a base-64 string represents - // a 6 bit value. A 32-bit integer can be - // represented using 6 characters (with some - // redundancy). - // - // - // LSL requires a base64 string to be 8 - // characters in length. LSL also uses '/' - // rather than '-' (MIME compliant). - // - // - // RFC 1341 used as a reference (as specified - // by the SecondLife Wiki). - // - // - // SL do not record any kind of exception for - // these functions, so the string to integer - // conversion returns '0' if an invalid - // character is encountered during conversion. - // - // - // References - // - // - // http://lslwiki.net/lslwiki/wakka.php?wakka=Base64 - // - // - // - // - // - // - - // - // Table for converting 6-bit integers into - // base-64 characters - // - - private static readonly char[] i2ctable = - { - 'A','B','C','D','E','F','G','H', - 'I','J','K','L','M','N','O','P', - 'Q','R','S','T','U','V','W','X', - 'Y','Z', - 'a','b','c','d','e','f','g','h', - 'i','j','k','l','m','n','o','p', - 'q','r','s','t','u','v','w','x', - 'y','z', - '0','1','2','3','4','5','6','7', - '8','9', - '+','/' - }; - - // - // Table for converting base-64 characters - // into 6-bit integers. - // - - private static readonly int[] c2itable = - { - -1,-1,-1,-1,-1,-1,-1,-1, // 0x - -1,-1,-1,-1,-1,-1,-1,-1, - -1,-1,-1,-1,-1,-1,-1,-1, // 1x - -1,-1,-1,-1,-1,-1,-1,-1, - -1,-1,-1,-1,-1,-1,-1,-1, // 2x - -1,-1,-1,63,-1,-1,-1,64, - 53,54,55,56,57,58,59,60, // 3x - 61,62,-1,-1,-1,0,-1,-1, - -1,1,2,3,4,5,6,7, // 4x - 8,9,10,11,12,13,14,15, - 16,17,18,19,20,21,22,23, // 5x - 24,25,26,-1,-1,-1,-1,-1, - -1,27,28,29,30,31,32,33, // 6x - 34,35,36,37,38,39,40,41, - 42,43,44,45,46,47,48,49, // 7x - 50,51,52,-1,-1,-1,-1,-1, - -1,-1,-1,-1,-1,-1,-1,-1, // 8x - -1,-1,-1,-1,-1,-1,-1,-1, - -1,-1,-1,-1,-1,-1,-1,-1, // 9x - -1,-1,-1,-1,-1,-1,-1,-1, - -1,-1,-1,-1,-1,-1,-1,-1, // Ax - -1,-1,-1,-1,-1,-1,-1,-1, - -1,-1,-1,-1,-1,-1,-1,-1, // Bx - -1,-1,-1,-1,-1,-1,-1,-1, - -1,-1,-1,-1,-1,-1,-1,-1, // Cx - -1,-1,-1,-1,-1,-1,-1,-1, - -1,-1,-1,-1,-1,-1,-1,-1, // Dx - -1,-1,-1,-1,-1,-1,-1,-1, - -1,-1,-1,-1,-1,-1,-1,-1, // Ex - -1,-1,-1,-1,-1,-1,-1,-1, - -1,-1,-1,-1,-1,-1,-1,-1, // Fx - -1,-1,-1,-1,-1,-1,-1,-1 - }; - - // - // Converts a 32-bit integer into a Base64 - // character string. Base64 character strings - // are always 8 characters long. All iinteger - // values are acceptable. - // - // - // 32-bit integer to be converted. - // - // - // 8 character string. The 1st six characters - // contain the encoded number, the last two - // characters are padded with "=". - // - - public string llIntegerToBase64(int number) - { - // uninitialized string - - char[] imdt = new char[8]; - - m_host.AddScriptLPS(1); - - // Manually unroll the loop - - imdt[7] = '='; - imdt[6] = '='; - imdt[5] = i2ctable[number<<4 & 0x3F]; - imdt[4] = i2ctable[number>>2 & 0x3F]; - imdt[3] = i2ctable[number>>8 & 0x3F]; - imdt[2] = i2ctable[number>>14 & 0x3F]; - imdt[1] = i2ctable[number>>20 & 0x3F]; - imdt[0] = i2ctable[number>>26 & 0x3F]; - - return new string(imdt); - } - - // - // Converts an eight character base-64 string - // into a 32-bit integer. - // - // - // 8 characters string to be converted. Other - // length strings return zero. - // - // - // Returns an integer representing the - // encoded value providedint he 1st 6 - // characters of the string. - // - // - // This is coded to behave like LSL's - // implementation (I think), based upon the - // information available at the Wiki. - // If more than 8 characters are supplied, - // zero is returned. - // If a NULL string is supplied, zero will - // be returned. - // If fewer than 6 characters are supplied, then - // the answer will reflect a partial - // accumulation. - // - // The 6-bit segments are - // extracted left-to-right in big-endian mode, - // which means that segment 6 only contains the - // two low-order bits of the 32 bit integer as - // its high order 2 bits. A short string therefore - // means loss of low-order information. E.g. - // - // |<---------------------- 32-bit integer ----------------------->|<-Pad->| - // |<--Byte 0----->|<--Byte 1----->|<--Byte 2----->|<--Byte 3----->|<-Pad->| - // |3|3|2|2|2|2|2|2|2|2|2|2|1|1|1|1|1|1|1|1|1|1| | | | | | | | | | |P|P|P|P| - // |1|0|9|8|7|6|5|4|3|2|1|0|9|8|7|6|5|4|3|2|1|0|9|8|7|6|5|4|3|2|1|0|P|P|P|P| - // | str[0] | str[1] | str[2] | str[3] | str[4] | str[6] | - // - // - // - - public LSL_Types.LSLInteger llBase64ToInteger(string str) - { - int number = 0; - int digit; - - m_host.AddScriptLPS(1); - - // Require a well-fromed base64 string - - if (str.Length > 8) - return 0; - - // The loop is unrolled in the interests - // of performance and simple necessity. - // - // MUST find 6 digits to be well formed - // -1 == invalid - // 0 == padding - - if ((digit=c2itable[str[0]])<=0) - { - return digit<0?(int)0:number; - } - number += --digit<<26; - - if ((digit=c2itable[str[1]])<=0) - { - return digit<0?(int)0:number; - } - number += --digit<<20; - - if ((digit=c2itable[str[2]])<=0) - { - return digit<0?(int)0:number; - } - number += --digit<<14; - - if ((digit=c2itable[str[3]])<=0) - { - return digit<0?(int)0:number; - } - number += --digit<<8; - - if ((digit=c2itable[str[4]])<=0) - { - return digit<0?(int)0:number; - } - number += --digit<<2; - - if ((digit=c2itable[str[5]])<=0) - { - return digit<0?(int)0:number; - } - number += --digit>>4; - - // ignore trailing padding - - return number; - } - - public double llGetGMTclock() - { - m_host.AddScriptLPS(1); - return DateTime.UtcNow.TimeOfDay.TotalSeconds; - } - - public string llGetSimulatorHostname() - { - m_host.AddScriptLPS(1); - return System.Environment.MachineName; - } - - public void llSetLocalRot(LSL_Types.Quaternion rot) - { - m_host.AddScriptLPS(1); - m_host.RotationOffset = new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s); - } - - // - // Scan the string supplied in 'src' and - // tokenize it based upon two sets of - // tokenizers provided in two lists, - // separators and spacers. - // - // - // - // Separators demarcate tokens and are - // elided as they are encountered. Spacers - // also demarcate tokens, but are themselves - // retained as tokens. - // - // Both separators and spacers may be arbitrarily - // long strings. i.e. ":::". - // - // The function returns an ordered list - // representing the tokens found in the supplied - // sources string. If two successive tokenizers - // are encountered, then a NULL entry is added - // to the list. - // - // It is a precondition that the source and - // toekizer lisst are non-null. If they are null, - // then a null pointer exception will be thrown - // while their lengths are being determined. - // - // A small amount of working memoryis required - // of approximately 8*#tokenizers. - // - // There are many ways in which this function - // can be implemented, this implementation is - // fairly naive and assumes that when the - // function is invooked with a short source - // string and/or short lists of tokenizers, then - // performance will not be an issue. - // - // In order to minimize the perofrmance - // effects of long strings, or large numbers - // of tokeizers, the function skips as far as - // possible whenever a toekenizer is found, - // and eliminates redundant tokenizers as soon - // as is possible. - // - // The implementation tries to avoid any copying - // of arrays or other objects. - // - - public LSL_Types.list llParseStringKeepNulls(string src, LSL_Types.list separators, LSL_Types.list spacers) - { - int beginning = 0; - int srclen = src.Length; - int seplen = separators.Length; - object[] separray = separators.Data; - int spclen = spacers.Length; - object[] spcarray = spacers.Data; - int mlen = seplen+spclen; - - int[] offset = new int[mlen+1]; - bool[] active = new bool[mlen]; - - int best; - int j; - - // Initial capacity reduces resize cost - - LSL_Types.list tokens = new LSL_Types.list(); - - m_host.AddScriptLPS(1); - - // All entries are initially valid - - for (int i = 0; i < mlen; i++) - active[i] = true; - - offset[mlen] = srclen; - - while (beginning < srclen) - { - - best = mlen; // as bad as it gets - - // Scan for separators - - for (j = 0; j < seplen; j++) - { - if (active[j]) - { - // scan all of the markers - if ((offset[j] = src.IndexOf((string)separray[j],beginning)) == -1) - { - // not present at all - active[j] = false; - } - else - { - // present and correct - if (offset[j] < offset[best]) - { - // closest so far - best = j; - if (offset[best] == beginning) - break; - } - } - } - } - - // Scan for spacers - - if (offset[best] != beginning) - { - for (j = seplen; (j < mlen) && (offset[best] > beginning); j++) - { - if (active[j]) - { - // scan all of the markers - if ((offset[j] = src.IndexOf((string)spcarray[j-seplen], beginning)) == -1) - { - // not present at all - active[j] = false; - } - else - { - // present and correct - if (offset[j] < offset[best]) - { - // closest so far - best = j; - } - } - } - } - } - - // This is the normal exit from the scanning loop - - if (best == mlen) - { - // no markers were found on this pass - // so we're pretty much done - tokens.Add(src.Substring(beginning, srclen - beginning)); - break; - } - - // Otherwise we just add the newly delimited token - // and recalculate where the search should continue. - - tokens.Add(src.Substring(beginning,offset[best]-beginning)); - - if (best < seplen) - { - beginning = offset[best] + ((string)separray[best]).Length; - } - else - { - beginning = offset[best] + ((string)spcarray[best - seplen]).Length; - tokens.Add(spcarray[best - seplen]); - } - } - - // This an awkward an not very intuitive boundary case. If the - // last substring is a tokenizer, then there is an implied trailing - // null list entry. Hopefully the single comparison will not be too - // arduous. Alternatively the 'break' could be replced with a return - // but that's shabby programming. - - if (beginning == srclen) - { - if (srclen != 0) - tokens.Add(""); - } - - return tokens; - } - - public void llRezAtRoot(string inventory, LSL_Types.Vector3 position, LSL_Types.Vector3 velocity, - LSL_Types.Quaternion rot, int param) - { - m_host.AddScriptLPS(1); - NotImplemented("llRezAtRoot"); - } - - public LSL_Types.LSLInteger llGetObjectPermMask(int mask) - { - m_host.AddScriptLPS(1); - - int permmask = 0; - - if (mask == BuiltIn_Commands_BaseClass.MASK_BASE)//0 - { - permmask = (int)m_host.BaseMask; - } - - else if (mask == BuiltIn_Commands_BaseClass.MASK_OWNER)//1 - { - permmask = (int)m_host.OwnerMask; - } - - else if (mask == BuiltIn_Commands_BaseClass.MASK_GROUP)//2 - { - permmask = (int)m_host.GroupMask; - } - - else if (mask == BuiltIn_Commands_BaseClass.MASK_EVERYONE)//3 - { - permmask = (int)m_host.EveryoneMask; - } - - else if (mask == BuiltIn_Commands_BaseClass.MASK_NEXT)//4 - { - permmask = (int)m_host.NextOwnerMask; - } - - return permmask; - } - - public void llSetObjectPermMask(int mask, int value) - { - m_host.AddScriptLPS(1); - IConfigSource config = new IniConfigSource(Application.iniFilePath); - if (config.Configs["XEngine"] == null) - config.AddConfig("XEngine"); - - if (config.Configs["XEngine"].GetBoolean("AllowGodFunctions", false)) - { - if (World.ExternalChecks.ExternalChecksCanRunConsoleCommand(m_host.OwnerID)) - { - if (mask == BuiltIn_Commands_BaseClass.MASK_BASE)//0 - { - m_host.BaseMask = (uint)value; - } - - else if (mask == BuiltIn_Commands_BaseClass.MASK_OWNER)//1 - { - m_host.OwnerMask = (uint)value; - } - - else if (mask == BuiltIn_Commands_BaseClass.MASK_GROUP)//2 - { - m_host.GroupMask = (uint)value; - } - - else if (mask == BuiltIn_Commands_BaseClass.MASK_EVERYONE)//3 - { - m_host.EveryoneMask = (uint)value; - } - - else if (mask == BuiltIn_Commands_BaseClass.MASK_NEXT)//4 - { - m_host.NextOwnerMask = (uint)value; - } - } - } - } - - public LSL_Types.LSLInteger llGetInventoryPermMask(string item, int mask) - { - m_host.AddScriptLPS(1); - foreach (KeyValuePair inv in m_host.TaskInventory) - { - if (inv.Value.Name == item) - { - switch (mask) - { - case 0: - return (int)inv.Value.BaseMask; - case 1: - return (int)inv.Value.OwnerMask; - case 2: - return (int)inv.Value.GroupMask; - case 3: - return (int)inv.Value.EveryoneMask; - case 4: - return (int)inv.Value.NextOwnerMask; - } - } - } - return -1; - } - - public void llSetInventoryPermMask(string item, int mask, int value) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetInventoryPermMask"); - } - - public string llGetInventoryCreator(string item) - { - m_host.AddScriptLPS(1); - foreach (KeyValuePair inv in m_host.TaskInventory) - { - if (inv.Value.Name == item) - { - return inv.Value.CreatorID.ToString(); - } - } - llSay(0, "No item name '" + item + "'"); - return String.Empty; - } - - public void llOwnerSay(string msg) - { - m_host.AddScriptLPS(1); - - World.SimChatBroadcast(Helpers.StringToField(msg), ChatTypeEnum.Owner, 0, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false); -// IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface(); -// wComm.DeliverMessage(ChatTypeEnum.Owner, 0, m_host.Name, m_host.UUID, msg); - } - - public string llRequestSimulatorData(string simulator, int data) - { - try - { - m_host.AddScriptLPS(1); - - string reply = String.Empty; - - RegionInfo info = m_ScriptEngine.World.RequestClosestRegion(simulator); - - switch (data) - { - case 5: // DATA_SIM_POS - if (info == null) - return LLUUID.Zero.ToString(); - reply = new LSL_Types.Vector3( - info.RegionLocX * Constants.RegionSize, - info.RegionLocY * Constants.RegionSize, - 0).ToString(); - break; - case 6: // DATA_SIM_STATUS - if (info != null) - reply = "up"; // Duh! - else - reply = "unknown"; - break; - case 7: // DATA_SIM_RATING - if (info == null) - return LLUUID.Zero.ToString(); - int access = (int)info.EstateSettings.simAccess; - if (access == 21) - reply = "MATURE"; - else if (access == 13) - reply = "MATURE"; - else - reply = "UNKNOWN"; - break; - default: - return LLUUID.Zero.ToString(); // Raise no event - } - LLUUID rq = LLUUID.Random(); - - LLUUID tid = m_ScriptEngine.m_ASYNCLSLCommandManager. - m_Dataserver.RegisterRequest(m_localID, - m_itemID, rq.ToString()); - - m_ScriptEngine.m_ASYNCLSLCommandManager. - m_Dataserver.DataserverReply(rq.ToString(), reply); - - return tid.ToString(); - } - catch(Exception e) - { - Console.WriteLine(e.ToString()); - return LLUUID.Zero.ToString(); - } - } - - public void llForceMouselook(int mouselook) - { - m_host.AddScriptLPS(1); - NotImplemented("llForceMouselook"); - } - - public double llGetObjectMass(string id) - { - m_host.AddScriptLPS(1); - LLUUID key = new LLUUID(); - if (LLUUID.TryParse(id,out key)) - { - return (double) World.GetSceneObjectPart(World.Entities[key].LocalId).GetMass(); - } - return 0; - } - - /// - /// illListReplaceList removes the sub-list defined by the inclusive indices - /// start and end and inserts the src list in its place. The inclusive - /// nature of the indices means that at least one element must be deleted - /// if the indices are within the bounds of the existing list. I.e. 2,2 - /// will remove the element at index 2 and replace it with the source - /// list. Both indices may be negative, with the usual interpretation. An - /// interesting case is where end is lower than start. As these indices - /// bound the list to be removed, then 0->end, and start->lim are removed - /// and the source list is added as a suffix. - /// - - public LSL_Types.list llListReplaceList(LSL_Types.list dest, LSL_Types.list src, int start, int end) - { - LSL_Types.list pref = null; - - m_host.AddScriptLPS(1); - - // Note that although we have normalized, both - // indices could still be negative. - if (start < 0) - { - start = start+dest.Length; - } - - if (end < 0) - { - end = end+dest.Length; - } - // The comventional case, remove a sequence starting with - // start and ending with end. And then insert the source - // list. - if (start <= end) - { - // If greater than zero, then there is going to be a - // surviving prefix. Otherwise the inclusive nature - // of the indices mean that we're going to add the - // source list as a prefix. - if (start > 0) - { - pref = dest.GetSublist(0,start-1); - // Only add a suffix if there is something - // beyond the end index (it's inclusive too). - if (end + 1 < dest.Length) - { - return pref + src + dest.GetSublist(end + 1, -1); - } - else - { - return pref + src; - } - } - // If start is less than or equal to zero, then - // the new list is simply a prefix. We still need to - // figure out any necessary surgery to the destination - // based upon end. Note that if end exceeds the upper - // bound in this case, the entire destination list - // is removed. - else - { - if (end + 1 < dest.Length) - { - return src + dest.GetSublist(end + 1, -1); - } - else - { - return src; - } - } - } - // Finally, if start > end, we strip away a prefix and - // a suffix, to leave the list that sits ens - // and start, and then tag on the src list. AT least - // that's my interpretation. We can get sublist to do - // this for us. Note that one, or both of the indices - // might have been negative. - else - { - return dest.GetSublist(end + 1, start - 1) + src; - } - } - - public void llLoadURL(string avatar_id, string message, string url) - { - m_host.AddScriptLPS(1); - LLUUID avatarId = new LLUUID(avatar_id); - m_ScriptEngine.World.SendUrlToUser(avatarId, m_host.Name, m_host.UUID, m_host.ObjectOwner, false, message, - url); - } - - public void llParcelMediaCommandList(LSL_Types.list commandList) - { - m_host.AddScriptLPS(1); - NotImplemented("llParcelMediaCommandList"); - } - - public void llParcelMediaQuery() - { - m_host.AddScriptLPS(1); - NotImplemented("llParcelMediaQuery"); - } - - public LSL_Types.LSLInteger llModPow(int a, int b, int c) - { - m_host.AddScriptLPS(1); - Int64 tmp = 0; - Math.DivRem(Convert.ToInt64(Math.Pow(a, b)), c, out tmp); - return Convert.ToInt32(tmp); - } - - public LSL_Types.LSLInteger llGetInventoryType(string name) - { - m_host.AddScriptLPS(1); - foreach (KeyValuePair inv in m_host.TaskInventory) - { - if (inv.Value.Name == name) - { - return inv.Value.InvType; - } - } - return -1; - } - - public void llSetPayPrice(int price, LSL_Types.list quick_pay_buttons) - { - m_host.AddScriptLPS(1); - - if (quick_pay_buttons.Data.Length != 4) - { - LSLError("List must have 4 elements"); - return; - } - m_host.ParentGroup.RootPart.PayPrice[0]=price; - m_host.ParentGroup.RootPart.PayPrice[1]=(int)quick_pay_buttons.Data[0]; - m_host.ParentGroup.RootPart.PayPrice[2]=(int)quick_pay_buttons.Data[1]; - m_host.ParentGroup.RootPart.PayPrice[3]=(int)quick_pay_buttons.Data[2]; - m_host.ParentGroup.RootPart.PayPrice[4]=(int)quick_pay_buttons.Data[3]; - } - - public LSL_Types.Vector3 llGetCameraPos() - { - m_host.AddScriptLPS(1); - NotImplemented("llGetCameraPos"); - return new LSL_Types.Vector3(); - } - - public LSL_Types.Quaternion llGetCameraRot() - { - m_host.AddScriptLPS(1); - NotImplemented("llGetCameraRot"); - return new LSL_Types.Quaternion(); - } - - public void llSetPrimURL() - { - m_host.AddScriptLPS(1); - NotImplemented("llSetPrimURL"); - } - - public void llRefreshPrimURL() - { - m_host.AddScriptLPS(1); - NotImplemented("llRefreshPrimURL"); - } - - public string llEscapeURL(string url) - { - m_host.AddScriptLPS(1); - try - { - return Uri.EscapeUriString(url); - } - catch (Exception ex) - { - return "llEscapeURL: " + ex.ToString(); - } - } - - public string llUnescapeURL(string url) - { - m_host.AddScriptLPS(1); - try - { - return Uri.UnescapeDataString(url); - } - catch (Exception ex) - { - return "llUnescapeURL: " + ex.ToString(); - } - } - - public void llMapDestination(string simname, LSL_Types.Vector3 pos, LSL_Types.Vector3 look_at) - { - m_host.AddScriptLPS(1); - NotImplemented("llMapDestination"); - } - - public void llAddToLandBanList(string avatar, double hours) - { - m_host.AddScriptLPS(1); - LLUUID key; - LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData; - if (land.ownerID == m_host.OwnerID) - { - ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry(); - if (LLUUID.TryParse(avatar, out key)) - { - entry.AgentID = key; - entry.Flags = ParcelManager.AccessList.Ban; - entry.Time = DateTime.Now.AddHours(hours); - land.parcelAccessList.Add(entry); - } - } - } - - public void llRemoveFromLandPassList(string avatar) - { - m_host.AddScriptLPS(1); - LLUUID key; - LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData; - if (land.ownerID == m_host.OwnerID) - { - if (LLUUID.TryParse(avatar, out key)) - { - foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList) - { - if (entry.AgentID == key && entry.Flags == ParcelManager.AccessList.Access) - { - land.parcelAccessList.Remove(entry); - break; - } - } - } - } - } - - public void llRemoveFromLandBanList(string avatar) - { - m_host.AddScriptLPS(1); - LLUUID key; - LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData; - if (land.ownerID == m_host.OwnerID) - { - if (LLUUID.TryParse(avatar, out key)) - { - foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList) - { - if (entry.AgentID == key && entry.Flags == ParcelManager.AccessList.Ban) - { - land.parcelAccessList.Remove(entry); - break; - } - } - } - } - } - - public void llSetCameraParams(LSL_Types.list rules) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetCameraParams"); - } - - public void llClearCameraParams() - { - m_host.AddScriptLPS(1); - NotImplemented("llClearCameraParams"); - } - - public double llListStatistics(int operation, LSL_Types.list src) - { - m_host.AddScriptLPS(1); - LSL_Types.list nums = LSL_Types.list.ToDoubleList(src); - switch (operation) - { - case BuiltIn_Commands_BaseClass.LIST_STAT_RANGE: - return nums.Range(); - case BuiltIn_Commands_BaseClass.LIST_STAT_MIN: - return nums.Min(); - case BuiltIn_Commands_BaseClass.LIST_STAT_MAX: - return nums.Max(); - case BuiltIn_Commands_BaseClass.LIST_STAT_MEAN: - return nums.Mean(); - case BuiltIn_Commands_BaseClass.LIST_STAT_MEDIAN: - return nums.Median(); - case BuiltIn_Commands_BaseClass.LIST_STAT_NUM_COUNT: - return nums.NumericLength(); - case BuiltIn_Commands_BaseClass.LIST_STAT_STD_DEV: - return nums.StdDev(); - case BuiltIn_Commands_BaseClass.LIST_STAT_SUM: - return nums.Sum(); - case BuiltIn_Commands_BaseClass.LIST_STAT_SUM_SQUARES: - return nums.SumSqrs(); - case BuiltIn_Commands_BaseClass.LIST_STAT_GEOMETRIC_MEAN: - return nums.GeometricMean(); - case BuiltIn_Commands_BaseClass.LIST_STAT_HARMONIC_MEAN: - return nums.HarmonicMean(); - default: - return 0.0; - } - } - - public LSL_Types.LSLInteger llGetUnixTime() - { - m_host.AddScriptLPS(1); - return Util.UnixTimeSinceEpoch(); - } - - public LSL_Types.LSLInteger llGetParcelFlags(LSL_Types.Vector3 pos) - { - m_host.AddScriptLPS(1); - return (int)World.LandChannel.GetLandObject((float)pos.x, (float)pos.y).landData.landFlags; - } - - public LSL_Types.LSLInteger llGetRegionFlags() - { - m_host.AddScriptLPS(1); - return (int)World.RegionInfo.EstateSettings.regionFlags; - } - - public string llXorBase64StringsCorrect(string str1, string str2) - { - m_host.AddScriptLPS(1); - string ret = String.Empty; - string src1 = llBase64ToString(str1); - string src2 = llBase64ToString(str2); - int c = 0; - for (int i = 0; i < src1.Length; i++) - { - ret += src1[i] ^ src2[c]; - - c++; - if (c > src2.Length) - c = 0; - } - return llStringToBase64(ret); - } - - public string llHTTPRequest(string url, LSL_Types.list parameters, string body) - { - // Partial implementation: support for parameter flags needed - // see http://wiki.secondlife.com/wiki/LlHTTPRequest - // parameter flags support are implemented in ScriptsHttpRequests.cs - // in StartHttpRequest - - m_host.AddScriptLPS(1); - IHttpRequests httpScriptMod = - m_ScriptEngine.World.RequestModuleInterface(); - List param = new List(); - foreach (object o in parameters.Data) - { - param.Add(o.ToString()); - } - LLUUID reqID = httpScriptMod. - StartHttpRequest(m_localID, m_itemID, url, param, body); - - if (reqID != LLUUID.Zero) - return reqID.ToString(); - else - return null; - } - - public void llResetLandBanList() - { - m_host.AddScriptLPS(1); - LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData; - if (land.ownerID == m_host.OwnerID) - { - foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList) - { - if (entry.Flags == ParcelManager.AccessList.Ban) - { - land.parcelAccessList.Remove(entry); - } - } - } - } - - public void llResetLandPassList() - { - m_host.AddScriptLPS(1); - LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData; - if (land.ownerID == m_host.OwnerID) - { - foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList) - { - if (entry.Flags == ParcelManager.AccessList.Access) - { - land.parcelAccessList.Remove(entry); - } - } - } - } - - public LSL_Types.LSLInteger llGetParcelPrimCount(LSL_Types.Vector3 pos, int category, int sim_wide) - { - m_host.AddScriptLPS(1); - - LandData land = World.GetLandData((float)pos.x, (float)pos.y); - - if (land == null) - { - return 0; - } - - else - { - if (sim_wide == 1) - { - if (category == 0) - { - return land.simwidePrims; - } - - else - { - //public int simwideArea = 0; - return 0; - } - } - - else - { - if (category == 0)//Total Prims - { - return 0;//land. - } - - else if (category == 1)//Owner Prims - { - return land.ownerPrims; - } - - else if (category == 2)//Group Prims - { - return land.groupPrims; - } - - else if (category == 3)//Other Prims - { - return land.otherPrims; - } - - else if (category == 4)//Selected - { - return land.selectedPrims; - } - - else if (category == 5)//Temp - { - return 0;//land. - } - } - } - return 0; - } - - public LSL_Types.list llGetParcelPrimOwners(LSL_Types.Vector3 pos) - { - m_host.AddScriptLPS(1); - LandObject land = (LandObject)World.LandChannel.GetLandObject((float)pos.x, (float)pos.y); - LSL_Types.list ret = new LSL_Types.list(); - if (land != null) - { - foreach (KeyValuePair d in land.getLandObjectOwners()) - { - ret.Add(d.Key.ToString()); - ret.Add(d.Value); - } - } - return ret; - } - - public LSL_Types.LSLInteger llGetObjectPrimCount(string object_id) - { - m_host.AddScriptLPS(1); - SceneObjectPart part = World.GetSceneObjectPart(new LLUUID(object_id)); - if (part == null) - { - return 0; - } - else - { - return part.ParentGroup.Children.Count; - } - } - - public LSL_Types.LSLInteger llGetParcelMaxPrims(LSL_Types.Vector3 pos, int sim_wide) - { - m_host.AddScriptLPS(1); - // Alondria: This currently just is utilizing the normal grid's 0.22 prims/m2 calculation - // Which probably will be irrelevent in OpenSim.... - LandData land = World.GetLandData((float)pos.x, (float)pos.y); - - float bonusfactor = World.RegionInfo.EstateSettings.objectBonusFactor; - - if (land == null) - { - return 0; - } - - if (sim_wide == 1) - { - decimal v = land.simwideArea * (decimal)(0.22) * (decimal)bonusfactor; - - return (int)v; - } - - else - { - decimal v = land.area * (decimal)(0.22) * (decimal)bonusfactor; - - return (int)v; - } - - } - - public LSL_Types.list llGetParcelDetails(LSL_Types.Vector3 pos, LSL_Types.list param) - { - m_host.AddScriptLPS(1); - LandData land = World.GetLandData((float)pos.x, (float)pos.y); - if (land == null) - { - return new LSL_Types.list(0); - } - LSL_Types.list ret = new LSL_Types.list(); - foreach (object o in param.Data) - { - switch (o.ToString()) - { - case "0": - ret = ret + new LSL_Types.list(land.landName); - break; - case "1": - ret = ret + new LSL_Types.list(land.landDesc); - break; - case "2": - ret = ret + new LSL_Types.list(land.ownerID.ToString()); - break; - case "3": - ret = ret + new LSL_Types.list(land.groupID.ToString()); - break; - case "4": - ret = ret + new LSL_Types.list(land.area); - break; - default: - ret = ret + new LSL_Types.list(0); - break; - } - } - return ret; - } - - public void llSetLinkTexture(int linknumber, string texture, int face) - { - m_host.AddScriptLPS(1); - NotImplemented("llSetLinkTexture"); - } - - public string llStringTrim(string src, int type) - { - m_host.AddScriptLPS(1); - if (type == (int)BuiltIn_Commands_BaseClass.STRING_TRIM_HEAD) { return src.TrimStart(); } - if (type == (int)BuiltIn_Commands_BaseClass.STRING_TRIM_TAIL) { return src.TrimEnd(); } - if (type == (int)BuiltIn_Commands_BaseClass.STRING_TRIM) { return src.Trim(); } - return src; - } - - public LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args) - { - m_host.AddScriptLPS(1); - LSL_Types.list ret = new LSL_Types.list(); - LLUUID key = new LLUUID(); - if (LLUUID.TryParse(id, out key)) - { - ScenePresence av = World.GetScenePresence(key); - - if (av != null) - { - foreach (object o in args.Data) - { - switch (o.ToString()) - { - case "1": - ret.Add(av.Firstname + " " + av.Lastname); - break; - case "2": - ret.Add(""); - break; - case "3": - ret.Add(new LSL_Types.Vector3((double)av.AbsolutePosition.X, (double)av.AbsolutePosition.Y, (double)av.AbsolutePosition.Z)); - break; - case "4": - ret.Add(new LSL_Types.Quaternion((double)av.Rotation.x, (double)av.Rotation.y, (double)av.Rotation.z, (double)av.Rotation.w)); - break; - case "5": - ret.Add(new LSL_Types.Vector3(av.Velocity.X,av.Velocity.Y,av.Velocity.Z)); - break; - case "6": - ret.Add(id); - break; - case "7": - ret.Add(LLUUID.Zero.ToString()); - break; - case "8": - ret.Add(LLUUID.Zero.ToString()); - break; - } - } - return ret; - } - SceneObjectPart obj = World.GetSceneObjectPart(key); - if (obj != null) - { - foreach (object o in args.Data) - { - switch (o.ToString()) - { - case "1": - ret.Add(obj.Name); - break; - case "2": - ret.Add(obj.Description); - break; - case "3": - ret.Add(new LSL_Types.Vector3(obj.AbsolutePosition.X,obj.AbsolutePosition.Y,obj.AbsolutePosition.Z)); - break; - case "4": - ret.Add(new LSL_Types.Quaternion(obj.RotationOffset.X, obj.RotationOffset.Y, obj.RotationOffset.Z, obj.RotationOffset.W)); - break; - case "5": - ret.Add(new LSL_Types.Vector3(obj.Velocity.X, obj.Velocity.Y, obj.Velocity.Z)); - break; - case "6": - ret.Add(obj.OwnerID.ToString()); - break; - case "7": - ret.Add(obj.GroupID.ToString()); - break; - case "8": - ret.Add(obj.CreatorID.ToString()); - break; - } - } - return ret; - } - } - return new LSL_Types.list(); - } - - - internal LLUUID ScriptByName(string name) - { - foreach (TaskInventoryItem item in m_host.TaskInventory.Values) - { - if (item.Type == 10 && item.Name == name) - return item.ItemID; - } - return LLUUID.Zero; - } - - internal void ShoutError(string msg) - { - llShout(BuiltIn_Commands_BaseClass.DEBUG_CHANNEL, msg); - } - - - - internal void NotImplemented(string command) - { - if (throwErrorOnNotImplemented) - throw new NotImplementedException("Command not implemented: " + command); - } - - internal void Deprecated(string command) - { - throw new Exception("Command deprecated: " + command); - } - - internal void LSLError(string msg) - { - throw new Exception("LSL Runtime Error: " + msg); - } - - public delegate void AssetRequestCallback(LLUUID assetID, AssetBase asset); - private void WithNotecard(LLUUID assetID, AssetRequestCallback cb) - { - World.AssetCache.GetAsset(assetID, delegate(LLUUID i, AssetBase a) { cb(i, a); }, false); - } - - public string llGetNumberOfNotecardLines(string name) - { - m_host.AddScriptLPS(1); - - foreach (TaskInventoryItem item in m_host.TaskInventory.Values) - { - if (item.Type == 7 && item.Name == name) - { - LLUUID tid = m_ScriptEngine.m_ASYNCLSLCommandManager. - m_Dataserver.RegisterRequest(m_localID, - m_itemID, item.AssetID.ToString()); - if (NotecardCache.IsCached(item.AssetID)) - { - m_ScriptEngine.m_ASYNCLSLCommandManager. - m_Dataserver.DataserverReply(item.AssetID.ToString(), - NotecardCache.GetLines(item.AssetID).ToString()); - return tid.ToString(); - } - WithNotecard(item.AssetID, delegate (LLUUID id, AssetBase a) - { - System.Text.ASCIIEncoding enc = - new System.Text.ASCIIEncoding(); - string data = enc.GetString(a.Data); - //Console.WriteLine(data); - NotecardCache.Cache(id, data); - m_ScriptEngine.m_ASYNCLSLCommandManager. - m_Dataserver.DataserverReply(id.ToString(), - NotecardCache.GetLines(id).ToString()); - }); - - return tid.ToString(); - } - } - return LLUUID.Zero.ToString(); - } - - public string llGetNotecardLine(string name, int line) - { - m_host.AddScriptLPS(1); - - foreach (TaskInventoryItem item in m_host.TaskInventory.Values) - { - if (item.Type == 7 && item.Name == name) - { - LLUUID tid = m_ScriptEngine.m_ASYNCLSLCommandManager. - m_Dataserver.RegisterRequest(m_localID, - m_itemID, item.AssetID.ToString()); - if (NotecardCache.IsCached(item.AssetID)) - { - m_ScriptEngine.m_ASYNCLSLCommandManager. - m_Dataserver.DataserverReply(item.AssetID.ToString(), - NotecardCache.GetLine(item.AssetID, line)); - return tid.ToString(); - } - WithNotecard(item.AssetID, delegate (LLUUID id, AssetBase a) - { - System.Text.ASCIIEncoding enc = - new System.Text.ASCIIEncoding(); - string data = enc.GetString(a.Data); - //Console.WriteLine(data); - NotecardCache.Cache(id, data); - m_ScriptEngine.m_ASYNCLSLCommandManager. - m_Dataserver.DataserverReply(id.ToString(), - NotecardCache.GetLine(id, line)); - }); - - return tid.ToString(); - } - } - - return String.Empty; - } - - } - - public class NotecardCache - { - private class Notecard - { - public string[] text; - public DateTime lastRef; - } - - private static Dictionary m_Notecards = - new Dictionary(); - - public static void Cache(LLUUID assetID, string text) - { - CacheCheck(); - - lock (m_Notecards) - { - if (m_Notecards.ContainsKey(assetID)) - return; - - Notecard nc = new Notecard(); - nc.lastRef = DateTime.Now; - nc.text = ParseText(text.Replace("\r", "").Split('\n')); - m_Notecards[assetID] = nc; - } - } - - private static string[] ParseText(string[] input) - { - int idx = 0; - int level = 0; - List output = new List(); - string[] words; - - while (idx < input.Length) - { - if (input[idx] == "{") - { - level++; - idx++; - continue; - } - - if (input[idx]== "}") - { - level--; - idx++; - continue; - } - - switch (level) - { - case 0: - words = input[idx].Split(' '); // Linden text ver - int version = int.Parse(words[3]); - if (version != 2) - return new String[0]; - break; - case 1: - words = input[idx].Split(' '); - if (words[0] == "LLEmbeddedItems") - break; - if (words[0] == "Text") - { - int len = int.Parse(words[2]); - idx++; - - int count = -1; - - while (count < len) - { - int l = input[idx].Length; - string ln = input[idx]; - - int need = len-count-1; - if (ln.Length > need) - ln = ln.Substring(0, need); - - output.Add(ln); - count += ln.Length + 1; - idx++; - } - - return output.ToArray(); - } - break; - case 2: - words = input[idx].Split(' '); // count - if (words[0] == "count") - { - int c = int.Parse(words[1]); - if (c > 0) - return new String[0]; - break; - } - break; - } - idx++; - } - return output.ToArray(); - } - - public static bool IsCached(LLUUID assetID) - { - lock (m_Notecards) - { - return m_Notecards.ContainsKey(assetID); - } - } - - public static int GetLines(LLUUID assetID) - { - if (!IsCached(assetID)) - return -1; - - lock (m_Notecards) - { - m_Notecards[assetID].lastRef = DateTime.Now; - return m_Notecards[assetID].text.Length; - } - } - - public static string GetLine(LLUUID assetID, int line) - { - if (line < 0) - return ""; - - string data; - - if (!IsCached(assetID)) - return ""; - - lock (m_Notecards) - { - m_Notecards[assetID].lastRef = DateTime.Now; - - if (line >= m_Notecards[assetID].text.Length) - return "\n\n\n"; - - data = m_Notecards[assetID].text[line]; - if (data.Length > 255) - data = data.Substring(0, 255); - - return data; - } - } - - public static void CacheCheck() - { - foreach (LLUUID key in new List(m_Notecards.Keys)) - { - Notecard nc = m_Notecards[key]; - if (nc.lastRef.AddSeconds(30) < DateTime.Now) - m_Notecards.Remove(key); - } - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/OSSL_ScriptCommands.cs b/OpenSim/Region/ScriptEngine/XEngine/OSSL_ScriptCommands.cs deleted file mode 100644 index bc4e8ba..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/OSSL_ScriptCommands.cs +++ /dev/null @@ -1,553 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -using System; -using Axiom.Math; -using libsecondlife; -using Nini.Config; -using OpenSim.Framework.Console; -using OpenSim.Region.Environment.Interfaces; -using OpenSim.Region.Environment.Scenes; -using OpenSim.Region.ScriptEngine.XEngine.Script; - -namespace OpenSim.Region.ScriptEngine.XEngine -{ - [Serializable] - public class OSSL_ScriptCommands : MarshalByRefObject, IOSSL_ScriptCommands - { - internal XEngine m_ScriptEngine; - internal XScriptInstance m_Instance; - internal SceneObjectPart m_host; - internal uint m_localID; - internal LLUUID m_itemID; - - public OSSL_ScriptCommands(XEngine scriptEngine, - XScriptInstance instance, SceneObjectPart host, - uint localID, LLUUID itemID) - { - m_ScriptEngine = scriptEngine; - m_Instance = instance; - m_host = host; - m_localID = localID; - m_itemID = itemID; - } - - - // - // OpenSim functions - // - - public int osTerrainSetHeight(int x, int y, double val) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osTerrainSetHeight: permission denied"); - return 0; - } - - m_host.AddScriptLPS(1); - if (x > 255 || x < 0 || y > 255 || y < 0) - OSSLError("osTerrainSetHeight: Coordinate out of bounds"); - - if (World.ExternalChecks.ExternalChecksCanTerraformLand(m_host.OwnerID, new LLVector3(x, y, 0))) - { - World.Heightmap[x, y] = val; - return 1; - } - else - { - return 0; - } - } - - public double osTerrainGetHeight(int x, int y) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osTerrainGetHeight: permission denied"); - return 0.0; - } - - m_host.AddScriptLPS(1); - if (x > 255 || x < 0 || y > 255 || y < 0) - OSSLError("osTerrainGetHeight: Coordinate out of bounds"); - - return World.Heightmap[x, y]; - } - - public int osRegionRestart(double seconds) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osRegionRestart: permission denied"); - return 0; - } - - m_host.AddScriptLPS(1); - if (World.ExternalChecks.ExternalChecksCanIssueEstateCommand(m_host.OwnerID)) - { - World.Restart((float)seconds); - return 1; - } - else - { - return 0; - } - } - - public void osRegionNotice(string msg) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osRegionNotice: permission denied"); - return; - } - - m_host.AddScriptLPS(1); - World.SendGeneralAlert(msg); - } - - public void osSetRot(LLUUID target, Quaternion rotation) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osSetRot: permission denied"); - return; - } - - m_host.AddScriptLPS(1); - if (World.Entities.ContainsKey(target)) - { - World.Entities[target].Rotation = rotation; - } - else - { - OSSLError("osSetRot: Invalid target"); - } - } - - public string osSetDynamicTextureURL(string dynamicID, string contentType, string url, string extraParams, - int timer) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osSetDynamicTextureURL: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - if (dynamicID == String.Empty) - { - IDynamicTextureManager textureManager = World.RequestModuleInterface(); - LLUUID createdTexture = - textureManager.AddDynamicTextureURL(World.RegionInfo.RegionID, m_host.UUID, contentType, url, - extraParams, timer); - return createdTexture.ToString(); - } - else - { - //TODO update existing dynamic textures - } - - return LLUUID.Zero.ToString(); - } - - public string osSetDynamicTextureURLBlend(string dynamicID, string contentType, string url, string extraParams, - int timer, int alpha) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osSetDynamicTextureURLBlend: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - if (dynamicID == String.Empty) - { - IDynamicTextureManager textureManager = World.RequestModuleInterface(); - LLUUID createdTexture = - textureManager.AddDynamicTextureURL(World.RegionInfo.RegionID, m_host.UUID, contentType, url, - extraParams, timer, true, (byte) alpha); - return createdTexture.ToString(); - } - else - { - //TODO update existing dynamic textures - } - - return LLUUID.Zero.ToString(); - } - - public string osSetDynamicTextureData(string dynamicID, string contentType, string data, string extraParams, - int timer) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osSetDynamicTextureData: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - if (dynamicID == String.Empty) - { - IDynamicTextureManager textureManager = World.RequestModuleInterface(); - if (textureManager != null) - { - LLUUID createdTexture = - textureManager.AddDynamicTextureData(World.RegionInfo.RegionID, m_host.UUID, contentType, data, - extraParams, timer); - return createdTexture.ToString(); - } - } - else - { - //TODO update existing dynamic textures - } - - return LLUUID.Zero.ToString(); - } - - public string osSetDynamicTextureDataBlend(string dynamicID, string contentType, string data, string extraParams, - int timer, int alpha) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osSetDynamicTextureDataBlend: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - if (dynamicID == String.Empty) - { - IDynamicTextureManager textureManager = World.RequestModuleInterface(); - if (textureManager != null) - { - LLUUID createdTexture = - textureManager.AddDynamicTextureData(World.RegionInfo.RegionID, m_host.UUID, contentType, data, - extraParams, timer, true, (byte) alpha); - return createdTexture.ToString(); - } - } - else - { - //TODO update existing dynamic textures - } - - return LLUUID.Zero.ToString(); - } - - public bool osConsoleCommand(string command) - { - m_host.AddScriptLPS(1); - if (m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowosConsoleCommand", false)) - { - if (World.ExternalChecks.ExternalChecksCanRunConsoleCommand(m_host.OwnerID)) - { - MainConsole.Instance.RunCommand(command); - return true; - } - return false; - } - return false; - } - public void osSetPrimFloatOnWater(int floatYN) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osSetPrimFloatOnWater: permission denied"); - return; - } - - m_host.AddScriptLPS(1); - if (m_host.ParentGroup != null) - { - if (m_host.ParentGroup.RootPart != null) - { - m_host.ParentGroup.RootPart.SetFloatOnWater(floatYN); - } - } - } - - // Adam's super super custom animation functions - public void osAvatarPlayAnimation(string avatar, string animation) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osAvatarPlayAnimation: permission denied"); - return; - } - - m_host.AddScriptLPS(1); - if (World.Entities.ContainsKey(avatar) && World.Entities[avatar] is ScenePresence) - { - ScenePresence target = (ScenePresence)World.Entities[avatar]; - target.AddAnimation(avatar); - } - } - - public void osAvatarStopAnimation(string avatar, string animation) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osAvatarStopAnimation: permission denied"); - return; - } - - m_host.AddScriptLPS(1); - if (World.Entities.ContainsKey(avatar) && World.Entities[avatar] is ScenePresence) - { - ScenePresence target = (ScenePresence)World.Entities[avatar]; - target.RemoveAnimation(animation); - } - } - - //Texture draw functions - public string osMovePen(string drawList, int x, int y) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osMovePen: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - drawList += "MoveTo " + x + "," + y + ";"; - return drawList; - } - - public string osDrawLine(string drawList, int startX, int startY, int endX, int endY) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osDrawLine: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - drawList += "MoveTo "+ startX+","+ startY +"; LineTo "+endX +","+endY +"; "; - return drawList; - } - - public string osDrawLine(string drawList, int endX, int endY) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osDrawLine: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - drawList += "LineTo " + endX + "," + endY + "; "; - return drawList; - } - - public string osDrawText(string drawList, string text) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osDrawText: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - drawList += "Text " + text + "; "; - return drawList; - } - - public string osDrawEllipse(string drawList, int width, int height) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osDrawEllipse: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - drawList += "Ellipse " + width + "," + height + "; "; - return drawList; - } - - public string osDrawRectangle(string drawList, int width, int height) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osDrawRectangle: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - drawList += "Rectangle " + width + "," + height + "; "; - return drawList; - } - - public string osDrawFilledRectangle(string drawList, int width, int height) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osDrawFilledRectangle: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - drawList += "FillRectangle " + width + "," + height + "; "; - return drawList; - } - - public string osSetFontSize(string drawList, int fontSize) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osSetFontSize: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - drawList += "FontSize "+ fontSize +"; "; - return drawList; - } - - public string osSetPenSize(string drawList, int penSize) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osSetPenSize: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - drawList += "PenSize " + penSize + "; "; - return drawList; - } - - public string osSetPenColour(string drawList, string colour) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osSetPenColour: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - drawList += "PenColour " + colour + "; "; - return drawList; - } - - public string osDrawImage(string drawList, int width, int height, string imageUrl) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osDrawImage: permission denied"); - return String.Empty; - } - - m_host.AddScriptLPS(1); - drawList +="Image " +width + "," + height+ ","+ imageUrl +"; " ; - return drawList; - } - - public void osSetStateEvents(int events) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osSetStateEvents: permission denied"); - return; - } - - m_host.SetScriptEvents(m_itemID, events); - } - - public void osSetRegionWaterHeight(double height) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osSetRegionWaterHeight: permission denied"); - return; - } - - m_host.AddScriptLPS(1); - //Check to make sure that the script's owner is the estate manager/master - //World.Permissions.GenericEstatePermission( - if (World.ExternalChecks.ExternalChecksCanBeGodLike(m_host.OwnerID)) - { - World.EventManager.TriggerRequestChangeWaterHeight((float)height); - } - } - - public double osList2Double(LSL_Types.list src, int index) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osList2Double: permission denied"); - return 0.0; - } - - m_host.AddScriptLPS(1); - if (index < 0) - { - index = src.Length + index; - } - if (index >= src.Length) - { - return 0.0; - } - return Convert.ToDouble(src.Data[index]); - } - - public void osSetParcelMediaURL(string url) - { - if (!m_ScriptEngine.ScriptConfigSource.GetBoolean("AllowOSFunctions", false)) - { - OSSLError("osSetParcelMediaURL: permission denied"); - return; - } - - m_host.AddScriptLPS(1); - LLUUID landowner = World.GetLandOwner(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y); - - if (landowner == LLUUID.Zero) - { - return; - } - - if (landowner != m_host.ObjectOwner) - { - return; - } - - World.SetLandMediaURL(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, url); - } - - public Scene World - { - get { return m_ScriptEngine.World; } - } - - internal void OSSLError(string msg) - { - throw new Exception("OSSL Runtime Error: " + msg); - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/Script/AssemblyResolver.cs b/OpenSim/Region/ScriptEngine/XEngine/Script/AssemblyResolver.cs deleted file mode 100644 index cf15b67..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/Script/AssemblyResolver.cs +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using System.IO; -using System.Reflection; - -namespace OpenSim.Region.ScriptEngine.XEngine.Script -{ - [Serializable] - public class AssemblyResolver - { - public static Assembly OnAssemblyResolve(object sender, - ResolveEventArgs args) - { - if (!(sender is System.AppDomain)) - return null; - - AppDomain myDomain = (AppDomain)sender; - string dirName = myDomain.FriendlyName; - - string[] pathList = new string[] {"bin", "ScriptEngines", - Path.Combine("ScriptEngines", dirName)}; - - string assemblyName = args.Name; - if (assemblyName.IndexOf(",") != -1) - assemblyName = args.Name.Substring(0, args.Name.IndexOf(",")); - - foreach (string s in pathList) - { - string path = Path.Combine(Directory.GetCurrentDirectory(), - Path.Combine(s, assemblyName))+".dll"; - - if (File.Exists(path)) - return Assembly.LoadFrom(path); - } - - return null; - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/Script/BuiltIn_Commands_BaseClass.cs b/OpenSim/Region/ScriptEngine/XEngine/Script/BuiltIn_Commands_BaseClass.cs deleted file mode 100644 index fc9f8fc..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/Script/BuiltIn_Commands_BaseClass.cs +++ /dev/null @@ -1,2397 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using System.Runtime.Remoting.Lifetime; -using System.Threading; -using System.Reflection; -using System.Collections; -using System.Collections.Generic; -using OpenSim.Region.Environment.Interfaces; -using integer = OpenSim.Region.ScriptEngine.XEngine.Script.LSL_Types.LSLInteger; -using key = System.String; -using vector = OpenSim.Region.ScriptEngine.XEngine.Script.LSL_Types.Vector3; -using rotation = OpenSim.Region.ScriptEngine.XEngine.Script.LSL_Types.Quaternion; - -namespace OpenSim.Region.ScriptEngine.XEngine.Script -{ - public class BuiltIn_Commands_BaseClass : MarshalByRefObject, IOSSL_ScriptCommands, ILSL_ScriptCommands, IScript - { - //private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); - - // Object never expires - public override Object InitializeLifetimeService() - { - //Console.WriteLine("LSL_BaseClass: InitializeLifetimeService()"); - // return null; - ILease lease = (ILease)base.InitializeLifetimeService(); - - if (lease.CurrentState == LeaseState.Initial) - { - lease.InitialLeaseTime = TimeSpan.Zero; // TimeSpan.FromMinutes(1); - //lease.SponsorshipTimeout = TimeSpan.FromMinutes(2); - //lease.RenewOnCallTime = TimeSpan.FromSeconds(2); - } - return lease; - } - - public ILSL_ScriptCommands m_LSL_Functions; - public IOSSL_ScriptCommands m_OSSL_Functions; - - public BuiltIn_Commands_BaseClass() - { - } - - public Type Start(ILSL_ScriptCommands LSL_Functions, IOSSL_ScriptCommands OSSL_Functions) - { - m_LSL_Functions = LSL_Functions; - m_OSSL_Functions = OSSL_Functions; - m_InitialValues=GetVars(); - return GetType(); - } - - private Dictionary m_InitialValues = - new Dictionary(); - private Dictionary m_Fields = - new Dictionary(); - - public Dictionary GetVars() - { - Dictionary vars = new Dictionary(); - - if (m_Fields == null) - return vars; - - m_Fields.Clear(); - - Type t = GetType(); - - FieldInfo[] fields = t.GetFields(BindingFlags.NonPublic | - BindingFlags.Public | - BindingFlags.Instance | - BindingFlags.DeclaredOnly); - - foreach (FieldInfo field in fields) - { - m_Fields[field.Name]=field; - - vars[field.Name]=field.GetValue(this); - } - - return vars; - } - - public void SetVars(Dictionary vars) - { - foreach (KeyValuePair var in vars) - { - if (m_Fields.ContainsKey(var.Key)) - { - m_Fields[var.Key].SetValue(this, var.Value); - } - } - } - - public void ResetVars() - { - SetVars(m_InitialValues); - } - - public string State - { - get { return m_LSL_Functions.State; } - set { m_LSL_Functions.State = value; } - } - - public void state(string newState) - { - m_LSL_Functions.state(newState); - } - - public void llSay(int channelID, string text) - { - m_LSL_Functions.llSay(channelID, text); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - // They are only forwarders to LSL_BuiltIn_Commands.cs - // - - public ICommander GetCommander(string name) - { - return m_LSL_Functions.GetCommander(name); - } - - public double llSin(double f) - { - return m_LSL_Functions.llSin(f); - } - public double llCos(double f) - { - return m_LSL_Functions.llCos(f); - } - - public double llTan(double f) - { - return m_LSL_Functions.llTan(f); - } - - public double llAtan2(double x, double y) - { - return m_LSL_Functions.llAtan2(x, y); - } - - public double llSqrt(double f) - { - return m_LSL_Functions.llSqrt(f); - } - - public double llPow(double fbase, double fexponent) - { - return m_LSL_Functions.llPow(fbase, fexponent); - } - - public LSL_Types.LSLInteger llAbs(int i) - { - return m_LSL_Functions.llAbs(i); - } - - public double llFabs(double f) - { - return m_LSL_Functions.llFabs(f); - } - - public double llFrand(double mag) - { - return m_LSL_Functions.llFrand(mag); - } - - public LSL_Types.LSLInteger llFloor(double f) - { - return m_LSL_Functions.llFloor(f); - } - - public LSL_Types.LSLInteger llCeil(double f) - { - return m_LSL_Functions.llCeil(f); - } - - public LSL_Types.LSLInteger llRound(double f) - { - return m_LSL_Functions.llRound(f); - } - - public double llVecMag(vector v) - { - return m_LSL_Functions.llVecMag(v); - } - - public vector llVecNorm(vector v) - { - return m_LSL_Functions.llVecNorm(v); - } - - public double llVecDist(vector a, vector b) - { - return m_LSL_Functions.llVecDist(a, b); - } - - public vector llRot2Euler(rotation r) - { - return m_LSL_Functions.llRot2Euler(r); - } - - public rotation llEuler2Rot(vector v) - { - return m_LSL_Functions.llEuler2Rot(v); - } - - public rotation llAxes2Rot(vector fwd, vector left, vector up) - { - return m_LSL_Functions.llAxes2Rot(fwd, left, up); - } - - public vector llRot2Fwd(rotation r) - { - return m_LSL_Functions.llRot2Fwd(r); - } - - public vector llRot2Left(rotation r) - { - return m_LSL_Functions.llRot2Left(r); - } - - public vector llRot2Up(rotation r) - { - return m_LSL_Functions.llRot2Up(r); - } - - public rotation llRotBetween(vector start, vector end) - { - return m_LSL_Functions.llRotBetween(start, end); - } - - public void llWhisper(int channelID, string text) - { - m_LSL_Functions.llWhisper(channelID, text); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public void llShout(int channelID, string text) - { - m_LSL_Functions.llShout(channelID, text); - } - - public void llRegionSay(int channelID, string text) - { - m_LSL_Functions.llRegionSay(channelID, text); - } - - public LSL_Types.LSLInteger llListen(int channelID, string name, string ID, string msg) - { - return m_LSL_Functions.llListen(channelID, name, ID, msg); - } - - public void llListenControl(int number, int active) - { - m_LSL_Functions.llListenControl(number, active); - } - - public void llListenRemove(int number) - { - m_LSL_Functions.llListenRemove(number); - } - - public void llSensor(string name, string id, int type, double range, double arc) - { - m_LSL_Functions.llSensor(name, id, type, range, arc); - } - - public void llSensorRepeat(string name, string id, int type, double range, double arc, double rate) - { - m_LSL_Functions.llSensorRepeat(name, id, type, range, arc, rate); - } - - public void llSensorRemove() - { - m_LSL_Functions.llSensorRemove(); - } - - public string llDetectedName(int number) - { - return m_LSL_Functions.llDetectedName(number); - } - - public string llDetectedKey(int number) - { - return m_LSL_Functions.llDetectedKey(number); - } - - public string llDetectedOwner(int number) - { - return m_LSL_Functions.llDetectedOwner(number); - } - - public LSL_Types.LSLInteger llDetectedType(int number) - { - return m_LSL_Functions.llDetectedType(number); - } - - public vector llDetectedPos(int number) - { - return m_LSL_Functions.llDetectedPos(number); - } - - public vector llDetectedVel(int number) - { - return m_LSL_Functions.llDetectedVel(number); - } - - public vector llDetectedGrab(int number) - { - return m_LSL_Functions.llDetectedGrab(number); - } - - public rotation llDetectedRot(int number) - { - return m_LSL_Functions.llDetectedRot(number); - } - - public LSL_Types.LSLInteger llDetectedGroup(int number) - { - return m_LSL_Functions.llDetectedGroup(number); - } - - public LSL_Types.LSLInteger llDetectedLinkNumber(int number) - { - return m_LSL_Functions.llDetectedLinkNumber(number); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public void llDie() - { - m_LSL_Functions.llDie(); - } - - public double llGround(vector offset) - { - return m_LSL_Functions.llGround(offset); - } - - public double llCloud(vector offset) - { - return m_LSL_Functions.llCloud(offset); - } - - public vector llWind(vector offset) - { - return m_LSL_Functions.llWind(offset); - } - - public void llSetStatus(int status, int value) - { - m_LSL_Functions.llSetStatus(status, value); - } - - public LSL_Types.LSLInteger llGetStatus(int status) - { - return m_LSL_Functions.llGetStatus(status); - } - - public void llSetScale(vector scale) - { - m_LSL_Functions.llSetScale(scale); - } - - public vector llGetScale() - { - return m_LSL_Functions.llGetScale(); - } - - public void llSetColor(vector color, int face) - { - m_LSL_Functions.llSetColor(color, face); - } - - public double llGetAlpha(int face) - { - return m_LSL_Functions.llGetAlpha(face); - } - - public void llSetAlpha(double alpha, int face) - { - m_LSL_Functions.llSetAlpha(alpha, face); - } - - public vector llGetColor(int face) - { - return m_LSL_Functions.llGetColor(face); - } - - public void llSetTexture(string texture, int face) - { - m_LSL_Functions.llSetTexture(texture, face); - } - - public void llScaleTexture(double u, double v, int face) - { - m_LSL_Functions.llScaleTexture(u, v, face); - } - - public void llOffsetTexture(double u, double v, int face) - { - m_LSL_Functions.llOffsetTexture(u, v, face); - } - - public void llRotateTexture(double rotation, int face) - { - m_LSL_Functions.llRotateTexture(rotation, face); - } - - public string llGetTexture(int face) - { - return m_LSL_Functions.llGetTexture(face); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public void llSetPos(vector pos) - { - m_LSL_Functions.llSetPos(pos); - } - - public vector llGetPos() - { - return m_LSL_Functions.llGetPos(); - } - - public vector llGetLocalPos() - { - return m_LSL_Functions.llGetLocalPos(); - } - - public void llSetRot(rotation rot) - { - m_LSL_Functions.llSetRot(rot); - } - - public rotation llGetRot() - { - return m_LSL_Functions.llGetRot(); - } - - public rotation llGetLocalRot() - { - return m_LSL_Functions.llGetLocalRot(); - } - - public void llSetForce(vector force, int local) - { - m_LSL_Functions.llSetForce(force, local); - } - - public vector llGetForce() - { - return m_LSL_Functions.llGetForce(); - } - - public LSL_Types.LSLInteger llTarget(vector position, double range) - { - return m_LSL_Functions.llTarget(position, range); - } - - public void llTargetRemove(int number) - { - m_LSL_Functions.llTargetRemove(number); - } - - public LSL_Types.LSLInteger llRotTarget(rotation rot, double error) - { - return m_LSL_Functions.llRotTarget(rot, error); - } - - public void llRotTargetRemove(int number) - { - m_LSL_Functions.llRotTargetRemove(number); - } - - public void llMoveToTarget(vector target, double tau) - { - m_LSL_Functions.llMoveToTarget(target, tau); - } - - public void llStopMoveToTarget() - { - m_LSL_Functions.llStopMoveToTarget(); - } - - public void llApplyImpulse(vector force, int local) - { - m_LSL_Functions.llApplyImpulse(force, local); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public void llApplyRotationalImpulse(vector force, int local) - { - m_LSL_Functions.llApplyRotationalImpulse(force, local); - } - - public void llSetTorque(vector torque, int local) - { - m_LSL_Functions.llSetTorque(torque, local); - } - - public vector llGetTorque() - { - return m_LSL_Functions.llGetTorque(); - } - - public void llSetForceAndTorque(vector force, vector torque, int local) - { - m_LSL_Functions.llSetForceAndTorque(force, torque, local); - } - - public vector llGetVel() - { - return m_LSL_Functions.llGetVel(); - } - - public vector llGetAccel() - { - return m_LSL_Functions.llGetAccel(); - } - - public vector llGetOmega() - { - return m_LSL_Functions.llGetOmega(); - } - - public double llGetTimeOfDay() - { - return m_LSL_Functions.llGetTimeOfDay(); - } - - public double llGetWallclock() - { - return m_LSL_Functions.llGetWallclock(); - } - - public double llGetTime() - { - return m_LSL_Functions.llGetTime(); - } - - public void llResetTime() - { - m_LSL_Functions.llResetTime(); - } - - public double llGetAndResetTime() - { - return m_LSL_Functions.llGetAndResetTime(); - } - - public void llSound() - { - m_LSL_Functions.llSound(); - } - - public void llPlaySound(string sound, double volume) - { - m_LSL_Functions.llPlaySound(sound, volume); - } - - public void llLoopSound(string sound, double volume) - { - m_LSL_Functions.llLoopSound(sound, volume); - } - - public void llLoopSoundMaster(string sound, double volume) - { - m_LSL_Functions.llLoopSoundMaster(sound, volume); - } - - public void llLoopSoundSlave(string sound, double volume) - { - m_LSL_Functions.llLoopSoundSlave(sound, volume); - } - - public void llPlaySoundSlave(string sound, double volume) - { - m_LSL_Functions.llPlaySoundSlave(sound, volume); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public void llTriggerSound(string sound, double volume) - { - m_LSL_Functions.llTriggerSound(sound, volume); - } - - public void llStopSound() - { - m_LSL_Functions.llStopSound(); - } - - public void llPreloadSound(string sound) - { - m_LSL_Functions.llPreloadSound(sound); - } - - public string llGetSubString(string src, int start, int end) - { - return m_LSL_Functions.llGetSubString(src, start, end); - } - - public string llDeleteSubString(string src, int start, int end) - { - return m_LSL_Functions.llDeleteSubString(src, start, end); - } - - public string llInsertString(string dst, int position, string src) - { - return m_LSL_Functions.llInsertString(dst, position, src); - } - - public string llToUpper(string source) - { - return m_LSL_Functions.llToUpper(source); - } - - public string llToLower(string source) - { - return m_LSL_Functions.llToLower(source); - } - - public LSL_Types.LSLInteger llGiveMoney(string destination, int amount) - { - return m_LSL_Functions.llGiveMoney(destination, amount); - } - - public void llMakeExplosion() - { - m_LSL_Functions.llMakeExplosion(); - } - - public void llMakeFountain() - { - m_LSL_Functions.llMakeFountain(); - } - - public void llMakeSmoke() - { - m_LSL_Functions.llMakeSmoke(); - } - - public void llMakeFire() - { - m_LSL_Functions.llMakeFire(); - } - - public void llRezObject(string inventory, vector pos, vector vel, rotation rot, int param) - { - m_LSL_Functions.llRezObject(inventory, pos, vel, rot, param); - } - - public void llLookAt(vector target, double strength, double damping) - { - m_LSL_Functions.llLookAt(target, strength, damping); - } - - public void llStopLookAt() - { - m_LSL_Functions.llStopLookAt(); - } - - public void llSetTimerEvent(double sec) - { - m_LSL_Functions.llSetTimerEvent(sec); - } - - public void llSleep(double sec) - { - m_LSL_Functions.llSleep(sec); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public double llGetMass() - { - return m_LSL_Functions.llGetMass(); - } - - public void llCollisionFilter(string name, string id, int accept) - { - m_LSL_Functions.llCollisionFilter(name, id, accept); - } - - public void llTakeControls(int controls, int accept, int pass_on) - { - m_LSL_Functions.llTakeControls(controls, accept, pass_on); - } - - public void llReleaseControls() - { - m_LSL_Functions.llReleaseControls(); - } - - public void llAttachToAvatar(int attachment) - { - m_LSL_Functions.llAttachToAvatar(attachment); - } - - public void llDetachFromAvatar() - { - m_LSL_Functions.llDetachFromAvatar(); - } - - public void llTakeCamera() - { - m_LSL_Functions.llTakeCamera(); - } - - public void llReleaseCamera() - { - m_LSL_Functions.llReleaseCamera(); - } - - public string llGetOwner() - { - return m_LSL_Functions.llGetOwner(); - } - - public void llInstantMessage(string user, string message) - { - m_LSL_Functions.llInstantMessage(user, message); - } - - public void llEmail(string address, string subject, string message) - { - m_LSL_Functions.llEmail(address, subject, message); - } - - public void llGetNextEmail(string address, string subject) - { - m_LSL_Functions.llGetNextEmail(address, subject); - } - - public string llGetKey() - { - return m_LSL_Functions.llGetKey(); - } - - public void llSetBuoyancy(double buoyancy) - { - m_LSL_Functions.llSetBuoyancy(buoyancy); - } - - public void llSetHoverHeight(double height, int water, double tau) - { - m_LSL_Functions.llSetHoverHeight(height, water, tau); - } - - public void llStopHover() - { - m_LSL_Functions.llStopHover(); - } - - public void llMinEventDelay(double delay) - { - m_LSL_Functions.llMinEventDelay(delay); - } - - public void llSoundPreload() - { - m_LSL_Functions.llSoundPreload(); - } - - public void llRotLookAt(rotation target, double strength, double damping) - { - m_LSL_Functions.llRotLookAt(target, strength, damping); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public LSL_Types.LSLInteger llStringLength(string str) - { - return m_LSL_Functions.llStringLength(str); - } - - public void llStartAnimation(string anim) - { - m_LSL_Functions.llStartAnimation(anim); - } - - public void llStopAnimation(string anim) - { - m_LSL_Functions.llStopAnimation(anim); - } - - public void llPointAt() - { - m_LSL_Functions.llPointAt(); - } - - public void llStopPointAt() - { - m_LSL_Functions.llStopPointAt(); - } - - public void llTargetOmega(vector axis, double spinrate, double gain) - { - m_LSL_Functions.llTargetOmega(axis, spinrate, gain); - } - - public LSL_Types.LSLInteger llGetStartParameter() - { - return m_LSL_Functions.llGetStartParameter(); - } - - public void llGodLikeRezObject(string inventory, vector pos) - { - m_LSL_Functions.llGodLikeRezObject(inventory, pos); - } - - public void llRequestPermissions(string agent, int perm) - { - m_LSL_Functions.llRequestPermissions(agent, perm); - } - - public string llGetPermissionsKey() - { - return m_LSL_Functions.llGetPermissionsKey(); - } - - public LSL_Types.LSLInteger llGetPermissions() - { - return m_LSL_Functions.llGetPermissions(); - } - - public LSL_Types.LSLInteger llGetLinkNumber() - { - return m_LSL_Functions.llGetLinkNumber(); - } - - public void llSetLinkColor(int linknumber, vector color, int face) - { - m_LSL_Functions.llSetLinkColor(linknumber, color, face); - } - - public void llCreateLink(string target, int parent) - { - m_LSL_Functions.llCreateLink(target, parent); - } - - public void llBreakLink(int linknum) - { - m_LSL_Functions.llBreakLink(linknum); - } - - public void llBreakAllLinks() - { - m_LSL_Functions.llBreakAllLinks(); - } - - public string llGetLinkKey(int linknum) - { - return m_LSL_Functions.llGetLinkKey(linknum); - } - - public string llGetLinkName(int linknum) - { - return m_LSL_Functions.llGetLinkName(linknum); - } - - public LSL_Types.LSLInteger llGetInventoryNumber(int type) - { - return m_LSL_Functions.llGetInventoryNumber(type); - } - - public string llGetInventoryName(int type, int number) - { - return m_LSL_Functions.llGetInventoryName(type, number); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public void llSetScriptState(string name, int run) - { - m_LSL_Functions.llSetScriptState(name, run); - } - - public double llGetEnergy() - { - return m_LSL_Functions.llGetEnergy(); - } - - public void llGiveInventory(string destination, string inventory) - { - m_LSL_Functions.llGiveInventory(destination, inventory); - } - - public void llRemoveInventory(string item) - { - m_LSL_Functions.llRemoveInventory(item); - } - - public void llSetText(string text, vector color, double alpha) - { - m_LSL_Functions.llSetText(text, color, alpha); - } - - public double llWater(vector offset) - { - return m_LSL_Functions.llWater(offset); - } - - public void llPassTouches(int pass) - { - m_LSL_Functions.llPassTouches(pass); - } - - public string llRequestAgentData(string id, int data) - { - return m_LSL_Functions.llRequestAgentData(id, data); - } - - public string llRequestInventoryData(string name) - { - return m_LSL_Functions.llRequestInventoryData(name); - } - - public void llSetDamage(double damage) - { - m_LSL_Functions.llSetDamage(damage); - } - - public void llTeleportAgentHome(string agent) - { - m_LSL_Functions.llTeleportAgentHome(agent); - } - - public void llModifyLand(int action, int brush) - { - m_LSL_Functions.llModifyLand(action, brush); - } - - public void llCollisionSound(string impact_sound, double impact_volume) - { - m_LSL_Functions.llCollisionSound(impact_sound, impact_volume); - } - - public void llCollisionSprite(string impact_sprite) - { - m_LSL_Functions.llCollisionSprite(impact_sprite); - } - - public string llGetAnimation(string id) - { - return m_LSL_Functions.llGetAnimation(id); - } - - public void llResetScript() - { - m_LSL_Functions.llResetScript(); - } - - public void llMessageLinked(int linknum, int num, string str, string id) - { - m_LSL_Functions.llMessageLinked(linknum, num, str, id); - } - - public void llPushObject(string target, vector impulse, vector ang_impulse, int local) - { - m_LSL_Functions.llPushObject(target, impulse, ang_impulse, local); - } - - public void llPassCollisions(int pass) - { - m_LSL_Functions.llPassCollisions(pass); - } - - public string llGetScriptName() - { - return m_LSL_Functions.llGetScriptName(); - } - - public LSL_Types.LSLInteger llGetNumberOfSides() - { - return m_LSL_Functions.llGetNumberOfSides(); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public rotation llAxisAngle2Rot(vector axis, double angle) - { - return m_LSL_Functions.llAxisAngle2Rot(axis, angle); - } - - public vector llRot2Axis(rotation rot) - { - return m_LSL_Functions.llRot2Axis(rot); - } - - public double llRot2Angle(rotation rot) - { - return m_LSL_Functions.llRot2Angle(rot); - } - - public double llAcos(double val) - { - return m_LSL_Functions.llAcos(val); - } - - public double llAsin(double val) - { - return m_LSL_Functions.llAsin(val); - } - - public double llAngleBetween(rotation a, rotation b) - { - return m_LSL_Functions.llAngleBetween(a, b); - } - - public string llGetInventoryKey(string name) - { - return m_LSL_Functions.llGetInventoryKey(name); - } - - public void llAllowInventoryDrop(int add) - { - m_LSL_Functions.llAllowInventoryDrop(add); - } - - public vector llGetSunDirection() - { - return m_LSL_Functions.llGetSunDirection(); - } - - public vector llGetTextureOffset(int face) - { - return m_LSL_Functions.llGetTextureOffset(face); - } - - public vector llGetTextureScale(int side) - { - return m_LSL_Functions.llGetTextureScale(side); - } - - public double llGetTextureRot(int side) - { - return m_LSL_Functions.llGetTextureRot(side); - } - - public LSL_Types.LSLInteger llSubStringIndex(string source, string pattern) - { - return m_LSL_Functions.llSubStringIndex(source, pattern); - } - - public string llGetOwnerKey(string id) - { - return m_LSL_Functions.llGetOwnerKey(id); - } - - public vector llGetCenterOfMass() - { - return m_LSL_Functions.llGetCenterOfMass(); - } - - public LSL_Types.list llListSort(LSL_Types.list src, int stride, int ascending) - { - return m_LSL_Functions.llListSort(src, stride, ascending); - } - - public LSL_Types.LSLInteger llGetListLength(LSL_Types.list src) - { - return m_LSL_Functions.llGetListLength(src); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public LSL_Types.LSLInteger llList2Integer(LSL_Types.list src, int index) - { - return m_LSL_Functions.llList2Integer(src, index); - } - - public string llList2String(LSL_Types.list src, int index) - { - return m_LSL_Functions.llList2String(src, index); - } - - public string llList2Key(LSL_Types.list src, int index) - { - return m_LSL_Functions.llList2Key(src, index); - } - - public vector llList2Vector(LSL_Types.list src, int index) - { - return m_LSL_Functions.llList2Vector(src, index); - } - - public rotation llList2Rot(LSL_Types.list src, int index) - { - return m_LSL_Functions.llList2Rot(src, index); - } - - public LSL_Types.list llList2List(LSL_Types.list src, int start, int end) - { - return m_LSL_Functions.llList2List(src, start, end); - } - - public LSL_Types.list llDeleteSubList(LSL_Types.list src, int start, int end) - { - return m_LSL_Functions.llDeleteSubList(src, start, end); - } - - public LSL_Types.LSLInteger llGetListEntryType(LSL_Types.list src, int index) - { - return m_LSL_Functions.llGetListEntryType(src, index); - } - - public string llList2CSV(LSL_Types.list src) - { - return m_LSL_Functions.llList2CSV(src); - } - - public LSL_Types.list llCSV2List(string src) - { - return m_LSL_Functions.llCSV2List(src); - } - - public LSL_Types.list llListRandomize(LSL_Types.list src, int stride) - { - return m_LSL_Functions.llListRandomize(src, stride); - } - - public LSL_Types.list llList2ListStrided(LSL_Types.list src, int start, int end, int stride) - { - return m_LSL_Functions.llList2ListStrided(src, start, end, stride); - } - - public vector llGetRegionCorner() - { - return m_LSL_Functions.llGetRegionCorner(); - } - - public LSL_Types.list llListInsertList(LSL_Types.list dest, LSL_Types.list src, int start) - { - return m_LSL_Functions.llListInsertList(dest, src, start); - } - - public LSL_Types.LSLInteger llListFindList(LSL_Types.list src, LSL_Types.list test) - { - return m_LSL_Functions.llListFindList(src, test); - } - - public string llGetObjectName() - { - return m_LSL_Functions.llGetObjectName(); - } - - public void llSetObjectName(string name) - { - m_LSL_Functions.llSetObjectName(name); - } - - public string llGetDate() - { - return m_LSL_Functions.llGetDate(); - } - - public LSL_Types.LSLInteger llEdgeOfWorld(vector pos, vector dir) - { - return m_LSL_Functions.llEdgeOfWorld(pos, dir); - } - - public LSL_Types.LSLInteger llGetAgentInfo(string id) - { - return m_LSL_Functions.llGetAgentInfo(id); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public void llAdjustSoundVolume(double volume) - { - m_LSL_Functions.llAdjustSoundVolume(volume); - } - - public void llSetSoundQueueing(int queue) - { - m_LSL_Functions.llSetSoundQueueing(queue); - } - - public void llSetSoundRadius(double radius) - { - m_LSL_Functions.llSetSoundRadius(radius); - } - - public string llKey2Name(string id) - { - return m_LSL_Functions.llKey2Name(id); - } - - public void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate) - { - m_LSL_Functions.llSetTextureAnim(mode, face, sizex, sizey, start, length, rate); - } - - public void llTriggerSoundLimited(string sound, double volume, vector top_north_east, vector bottom_south_west) - { - m_LSL_Functions.llTriggerSoundLimited(sound, volume, top_north_east, bottom_south_west); - } - - public void llEjectFromLand(string pest) - { - m_LSL_Functions.llEjectFromLand(pest); - } - - public LSL_Types.list llParseString2List(string str, LSL_Types.list separators, LSL_Types.list spacers) - { - return m_LSL_Functions.llParseString2List(str,separators,spacers); - } - - public LSL_Types.LSLInteger llOverMyLand(string id) - { - return m_LSL_Functions.llOverMyLand(id); - } - - public string llGetLandOwnerAt(vector pos) - { - return m_LSL_Functions.llGetLandOwnerAt(pos); - } - - public string llGetNotecardLine(string name, int line) - { - return m_LSL_Functions.llGetNotecardLine(name, line); - } - - public vector llGetAgentSize(string id) - { - return m_LSL_Functions.llGetAgentSize(id); - } - - public LSL_Types.LSLInteger llSameGroup(string agent) - { - return m_LSL_Functions.llSameGroup(agent); - } - - public void llUnSit(string id) - { - m_LSL_Functions.llUnSit(id); - } - - public vector llGroundSlope(vector offset) - { - return m_LSL_Functions.llGroundSlope(offset); - } - - public vector llGroundNormal(vector offset) - { - return m_LSL_Functions.llGroundNormal(offset); - } - - public vector llGroundContour(vector offset) - { - return m_LSL_Functions.llGroundContour(offset); - } - - public LSL_Types.LSLInteger llGetAttached() - { - return m_LSL_Functions.llGetAttached(); - } - - public LSL_Types.LSLInteger llGetFreeMemory() - { - return m_LSL_Functions.llGetFreeMemory(); - } - - public string llGetRegionName() - { - return m_LSL_Functions.llGetRegionName(); - } - - public double llGetRegionTimeDilation() - { - return m_LSL_Functions.llGetRegionTimeDilation(); - } - - public double llGetRegionFPS() - { - return m_LSL_Functions.llGetRegionFPS(); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public void llParticleSystem(LSL_Types.list rules) - { - m_LSL_Functions.llParticleSystem(rules); - } - - public void llGroundRepel(double height, int water, double tau) - { - m_LSL_Functions.llGroundRepel(height, water, tau); - } - - public void llGiveInventoryList(string destination, string category, LSL_Types.list inventory) - { - m_LSL_Functions.llGiveInventoryList(destination, category, inventory); - } - - public void llSetVehicleType(int type) - { - m_LSL_Functions.llSetVehicleType(type); - } - - public void llSetVehicledoubleParam(int param, double value) - { - m_LSL_Functions.llSetVehicledoubleParam(param, value); - } - - public void llSetVehicleFloatParam(int param, float value) - { - m_LSL_Functions.llSetVehicleFloatParam(param, value); - } - - public void llSetVehicleVectorParam(int param, vector vec) - { - m_LSL_Functions.llSetVehicleVectorParam(param, vec); - } - - public void llSetVehicleRotationParam(int param, rotation rot) - { - m_LSL_Functions.llSetVehicleRotationParam(param, rot); - } - - public void llSetVehicleFlags(int flags) - { - m_LSL_Functions.llSetVehicleFlags(flags); - } - - public void llRemoveVehicleFlags(int flags) - { - m_LSL_Functions.llRemoveVehicleFlags(flags); - } - - public void llSitTarget(vector offset, rotation rot) - { - m_LSL_Functions.llSitTarget(offset, rot); - } - - public string llAvatarOnSitTarget() - { - return m_LSL_Functions.llAvatarOnSitTarget(); - } - - public void llAddToLandPassList(string avatar, double hours) - { - m_LSL_Functions.llAddToLandPassList(avatar, hours); - } - - public void llSetTouchText(string text) - { - m_LSL_Functions.llSetTouchText(text); - } - - public void llSetSitText(string text) - { - m_LSL_Functions.llSetSitText(text); - } - - public void llSetCameraEyeOffset(vector offset) - { - m_LSL_Functions.llSetCameraEyeOffset(offset); - } - - public void llSetCameraAtOffset(vector offset) - { - m_LSL_Functions.llSetCameraAtOffset(offset); - } - - public string llDumpList2String(LSL_Types.list src, string seperator) - { - return m_LSL_Functions.llDumpList2String(src, seperator); - } - - public LSL_Types.LSLInteger llScriptDanger(vector pos) - { - return m_LSL_Functions.llScriptDanger(pos); - } - - public void llDialog(string avatar, string message, LSL_Types.list buttons, int chat_channel) - { - m_LSL_Functions.llDialog(avatar, message, buttons, chat_channel); - } - - public void llVolumeDetect(int detect) - { - m_LSL_Functions.llVolumeDetect(detect); - } - - public void llResetOtherScript(string name) - { - m_LSL_Functions.llResetOtherScript(name); - } - - public LSL_Types.LSLInteger llGetScriptState(string name) - { - return m_LSL_Functions.llGetScriptState(name); - } - - public void llRemoteLoadScript() - { - m_LSL_Functions.llRemoteLoadScript(); - } - - public void llSetRemoteScriptAccessPin(int pin) - { - m_LSL_Functions.llSetRemoteScriptAccessPin(pin); - } - - public void llRemoteLoadScriptPin(string target, string name, int pin, int running, int start_param) - { - m_LSL_Functions.llRemoteLoadScriptPin(target, name, pin, running, start_param); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public void llOpenRemoteDataChannel() - { - m_LSL_Functions.llOpenRemoteDataChannel(); - } - - public string llSendRemoteData(string channel, string dest, int idata, string sdata) - { - return m_LSL_Functions.llSendRemoteData(channel, dest, idata, sdata); - } - - public void llRemoteDataReply(string channel, string message_id, string sdata, int idata) - { - m_LSL_Functions.llRemoteDataReply(channel, message_id, sdata, idata); - } - - public void llCloseRemoteDataChannel(string channel) - { - m_LSL_Functions.llCloseRemoteDataChannel(channel); - } - - public string llMD5String(string src, int nonce) - { - return m_LSL_Functions.llMD5String(src, nonce); - } - - public void llSetPrimitiveParams(LSL_Types.list rules) - { - m_LSL_Functions.llSetPrimitiveParams(rules); - } - - public void llSetLinkPrimitiveParams(int linknumber, LSL_Types.list rules) - { - m_LSL_Functions.llSetLinkPrimitiveParams(linknumber, rules); - } - public string llStringToBase64(string str) - { - return m_LSL_Functions.llStringToBase64(str); - } - - public string llBase64ToString(string str) - { - return m_LSL_Functions.llBase64ToString(str); - } - - public void llXorBase64Strings() - { - m_LSL_Functions.llXorBase64Strings(); - } - - public void llRemoteDataSetRegion() - { - m_LSL_Functions.llRemoteDataSetRegion(); - } - - public double llLog10(double val) - { - return m_LSL_Functions.llLog10(val); - } - - public double llLog(double val) - { - return m_LSL_Functions.llLog(val); - } - - public LSL_Types.list llGetAnimationList(string id) - { - return m_LSL_Functions.llGetAnimationList(id); - } - - public void llSetParcelMusicURL(string url) - { - m_LSL_Functions.llSetParcelMusicURL(url); - } - - public vector llGetRootPosition() - { - return m_LSL_Functions.llGetRootPosition(); - } - - public rotation llGetRootRotation() - { - return m_LSL_Functions.llGetRootRotation(); - } - - public string llGetObjectDesc() - { - return m_LSL_Functions.llGetObjectDesc(); - } - - public void llSetObjectDesc(string desc) - { - m_LSL_Functions.llSetObjectDesc(desc); - } - - public string llGetCreator() - { - return m_LSL_Functions.llGetCreator(); - } - - public string llGetTimestamp() - { - return m_LSL_Functions.llGetTimestamp(); - } - - public void llSetLinkAlpha(int linknumber, double alpha, int face) - { - m_LSL_Functions.llSetLinkAlpha(linknumber, alpha, face); - } - - public LSL_Types.LSLInteger llGetNumberOfPrims() - { - return m_LSL_Functions.llGetNumberOfPrims(); - } - - public string llGetNumberOfNotecardLines(string name) - { - return m_LSL_Functions.llGetNumberOfNotecardLines(name); - } - - public LSL_Types.list llGetBoundingBox(string obj) - { - return m_LSL_Functions.llGetBoundingBox(obj); - } - - public vector llGetGeometricCenter() - { - return m_LSL_Functions.llGetGeometricCenter(); - } - - public LSL_Types.list llGetPrimitiveParams(LSL_Types.list rules) - { - return m_LSL_Functions.llGetPrimitiveParams(rules); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public string llIntegerToBase64(int number) - { - return m_LSL_Functions.llIntegerToBase64(number); - } - - public LSL_Types.LSLInteger llBase64ToInteger(string str) - { - return m_LSL_Functions.llBase64ToInteger(str); - } - - public double llGetGMTclock() - { - return m_LSL_Functions.llGetGMTclock(); - } - - public string llGetSimulatorHostname() - { - return m_LSL_Functions.llGetSimulatorHostname(); - } - - public void llSetLocalRot(rotation rot) - { - m_LSL_Functions.llSetLocalRot(rot); - } - - public LSL_Types.list llParseStringKeepNulls(string src, LSL_Types.list seperators, LSL_Types.list spacers) - { - return m_LSL_Functions.llParseStringKeepNulls(src, seperators, spacers); - } - - public void llRezAtRoot(string inventory, vector position, vector velocity, rotation rot, int param) - { - m_LSL_Functions.llRezAtRoot(inventory, position, velocity, rot, param); - } - - public LSL_Types.LSLInteger llGetObjectPermMask(int mask) - { - return m_LSL_Functions.llGetObjectPermMask(mask); - } - - public void llSetObjectPermMask(int mask, int value) - { - m_LSL_Functions.llSetObjectPermMask(mask, value); - } - - public LSL_Types.LSLInteger llGetInventoryPermMask(string item, int mask) - { - return m_LSL_Functions.llGetInventoryPermMask(item, mask); - } - - public void llSetInventoryPermMask(string item, int mask, int value) - { - m_LSL_Functions.llSetInventoryPermMask(item, mask, value); - } - - public string llGetInventoryCreator(string item) - { - return m_LSL_Functions.llGetInventoryCreator(item); - } - - public void llOwnerSay(string msg) - { - m_LSL_Functions.llOwnerSay(msg); - } - - public string llRequestSimulatorData(string simulator, int data) - { - return m_LSL_Functions.llRequestSimulatorData(simulator, data); - } - - public void llForceMouselook(int mouselook) - { - m_LSL_Functions.llForceMouselook(mouselook); - } - - public double llGetObjectMass(string id) - { - return m_LSL_Functions.llGetObjectMass(id); - } - - public LSL_Types.list llListReplaceList(LSL_Types.list dest, LSL_Types.list src, int start, int end) - { - return m_LSL_Functions.llListReplaceList(dest, src, start, end); - } - - public void llLoadURL(string avatar_id, string message, string url) - { - m_LSL_Functions.llLoadURL(avatar_id, message, url); - } - - public void llParcelMediaCommandList(LSL_Types.list commandList) - { - m_LSL_Functions.llParcelMediaCommandList(commandList); - } - - public void llParcelMediaQuery() - { - m_LSL_Functions.llParcelMediaQuery(); - } - - public LSL_Types.LSLInteger llModPow(int a, int b, int c) - { - return m_LSL_Functions.llModPow(a, b, c); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public LSL_Types.LSLInteger llGetInventoryType(string name) - { - return m_LSL_Functions.llGetInventoryType(name); - } - - public void llSetPayPrice(int price, LSL_Types.list quick_pay_buttons) - { - m_LSL_Functions.llSetPayPrice(price, quick_pay_buttons); - } - - public vector llGetCameraPos() - { - return m_LSL_Functions.llGetCameraPos(); - } - - public rotation llGetCameraRot() - { - return m_LSL_Functions.llGetCameraRot(); - } - - public void llSetPrimURL() - { - m_LSL_Functions.llSetPrimURL(); - } - - public void llRefreshPrimURL() - { - m_LSL_Functions.llRefreshPrimURL(); - } - - public string llEscapeURL(string url) - { - return m_LSL_Functions.llEscapeURL(url); - } - - public string llUnescapeURL(string url) - { - return m_LSL_Functions.llUnescapeURL(url); - } - - public void llMapDestination(string simname, vector pos, vector look_at) - { - m_LSL_Functions.llMapDestination(simname, pos, look_at); - } - - public void llAddToLandBanList(string avatar, double hours) - { - m_LSL_Functions.llAddToLandBanList(avatar, hours); - } - - public void llRemoveFromLandPassList(string avatar) - { - m_LSL_Functions.llRemoveFromLandPassList(avatar); - } - - public void llRemoveFromLandBanList(string avatar) - { - m_LSL_Functions.llRemoveFromLandBanList(avatar); - } - - public void llSetCameraParams(LSL_Types.list rules) - { - m_LSL_Functions.llSetCameraParams(rules); - } - - public void llClearCameraParams() - { - m_LSL_Functions.llClearCameraParams(); - } - - public double llListStatistics(int operation, LSL_Types.list src) - { - return m_LSL_Functions.llListStatistics(operation, src); - } - - public LSL_Types.LSLInteger llGetUnixTime() - { - return m_LSL_Functions.llGetUnixTime(); - } - - public LSL_Types.LSLInteger llGetParcelFlags(vector pos) - { - return m_LSL_Functions.llGetParcelFlags(pos); - } - - public LSL_Types.LSLInteger llGetRegionFlags() - { - return m_LSL_Functions.llGetRegionFlags(); - } - - public string llXorBase64StringsCorrect(string str1, string str2) - { - return m_LSL_Functions.llXorBase64StringsCorrect(str1, str2); - } - - public string llHTTPRequest(string url, LSL_Types.list parameters, string body) - { - return m_LSL_Functions.llHTTPRequest(url, parameters, body); - } - - public void llResetLandBanList() - { - m_LSL_Functions.llResetLandBanList(); - } - - public void llResetLandPassList() - { - m_LSL_Functions.llResetLandPassList(); - } - - public LSL_Types.LSLInteger llGetParcelPrimCount(vector pos, int category, int sim_wide) - { - return m_LSL_Functions.llGetParcelPrimCount(pos, category, sim_wide); - } - - public LSL_Types.list llGetParcelPrimOwners(vector pos) - { - return m_LSL_Functions.llGetParcelPrimOwners(pos); - } - - public LSL_Types.LSLInteger llGetObjectPrimCount(string object_id) - { - return m_LSL_Functions.llGetObjectPrimCount(object_id); - } - - // - // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs - // - public LSL_Types.LSLInteger llGetParcelMaxPrims(vector pos, int sim_wide) - { - return m_LSL_Functions.llGetParcelMaxPrims(pos, sim_wide); - } - - public LSL_Types.list llGetParcelDetails(vector pos, LSL_Types.list param) - { - return m_LSL_Functions.llGetParcelDetails(pos, param); - } - - public void llSetLinkTexture(int linknumber, string texture, int face) - { - m_LSL_Functions.llSetLinkTexture(linknumber, texture, face); - } - - public string llStringTrim(string src, int type) - { - return m_LSL_Functions.llStringTrim(src, type); - } - - public LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args) - { - return m_LSL_Functions.llGetObjectDetails(id, args); - } - - public double llList2Float(LSL_Types.list src, int index) - { - return m_LSL_Functions.llList2Float(src, index); - } - - // LSL CONSTANTS - public const int TRUE = 1; - public const int FALSE = 0; - - public const int STATUS_PHYSICS = 1; - public const int STATUS_ROTATE_X = 2; - public const int STATUS_ROTATE_Y = 4; - public const int STATUS_ROTATE_Z = 8; - public const int STATUS_PHANTOM = 16; - public const int STATUS_SANDBOX = 32; - public const int STATUS_BLOCK_GRAB = 64; - public const int STATUS_DIE_AT_EDGE = 128; - public const int STATUS_RETURN_AT_EDGE = 256; - public const int STATUS_CAST_SHADOWS = 512; - - public const int AGENT = 1; - public const int ACTIVE = 2; - public const int PASSIVE = 4; - public const int SCRIPTED = 8; - - public const int CONTROL_FWD = 1; - public const int CONTROL_BACK = 2; - public const int CONTROL_LEFT = 4; - public const int CONTROL_RIGHT = 8; - public const int CONTROL_UP = 16; - public const int CONTROL_DOWN = 32; - public const int CONTROL_ROT_LEFT = 256; - public const int CONTROL_ROT_RIGHT = 512; - public const int CONTROL_LBUTTON = 268435456; - public const int CONTROL_ML_LBUTTON = 1073741824; - - //Permissions - public const int PERMISSION_DEBIT = 2; - public const int PERMISSION_TAKE_CONTROLS = 4; - public const int PERMISSION_REMAP_CONTROLS = 8; - public const int PERMISSION_TRIGGER_ANIMATION = 16; - public const int PERMISSION_ATTACH = 32; - public const int PERMISSION_RELEASE_OWNERSHIP = 64; - public const int PERMISSION_CHANGE_LINKS = 128; - public const int PERMISSION_CHANGE_JOINTS = 256; - public const int PERMISSION_CHANGE_PERMISSIONS = 512; - public const int PERMISSION_TRACK_CAMERA = 1024; - - public const int AGENT_FLYING = 1; - public const int AGENT_ATTACHMENTS = 2; - public const int AGENT_SCRIPTED = 4; - public const int AGENT_MOUSELOOK = 8; - public const int AGENT_SITTING = 16; - public const int AGENT_ON_OBJECT = 32; - public const int AGENT_AWAY = 64; - public const int AGENT_WALKING = 128; - public const int AGENT_IN_AIR = 256; - public const int AGENT_TYPING = 512; - public const int AGENT_CROUCHING = 1024; - public const int AGENT_BUSY = 2048; - public const int AGENT_ALWAYS_RUN = 4096; - - //Particle Systems - public const int PSYS_PART_INTERP_COLOR_MASK = 1; - public const int PSYS_PART_INTERP_SCALE_MASK = 2; - public const int PSYS_PART_BOUNCE_MASK = 4; - public const int PSYS_PART_WIND_MASK = 8; - public const int PSYS_PART_FOLLOW_SRC_MASK = 16; - public const int PSYS_PART_FOLLOW_VELOCITY_MASK = 32; - public const int PSYS_PART_TARGET_POS_MASK = 64; - public const int PSYS_PART_TARGET_LINEAR_MASK = 128; - public const int PSYS_PART_EMISSIVE_MASK = 256; - public const int PSYS_PART_FLAGS = 0; - public const int PSYS_PART_START_COLOR = 1; - public const int PSYS_PART_START_ALPHA = 2; - public const int PSYS_PART_END_COLOR = 3; - public const int PSYS_PART_END_ALPHA = 4; - public const int PSYS_PART_START_SCALE = 5; - public const int PSYS_PART_END_SCALE = 6; - public const int PSYS_PART_MAX_AGE = 7; - public const int PSYS_SRC_ACCEL = 8; - public const int PSYS_SRC_PATTERN = 9; - public const int PSYS_SRC_INNERANGLE = 10; - public const int PSYS_SRC_OUTERANGLE = 11; - public const int PSYS_SRC_TEXTURE = 12; - public const int PSYS_SRC_BURST_RATE = 13; - public const int PSYS_SRC_BURST_PART_COUNT = 15; - public const int PSYS_SRC_BURST_RADIUS = 16; - public const int PSYS_SRC_BURST_SPEED_MIN = 17; - public const int PSYS_SRC_BURST_SPEED_MAX = 18; - public const int PSYS_SRC_MAX_AGE = 19; - public const int PSYS_SRC_TARGET_KEY = 20; - public const int PSYS_SRC_OMEGA = 21; - public const int PSYS_SRC_ANGLE_BEGIN = 22; - public const int PSYS_SRC_ANGLE_END = 23; - public const int PSYS_SRC_PATTERN_DROP = 1; - public const int PSYS_SRC_PATTERN_EXPLODE = 2; - public const int PSYS_SRC_PATTERN_ANGLE = 4; - public const int PSYS_SRC_PATTERN_ANGLE_CONE = 8; - public const int PSYS_SRC_PATTERN_ANGLE_CONE_EMPTY = 16; - - public const int VEHICLE_TYPE_NONE = 0; - public const int VEHICLE_TYPE_SLED = 1; - public const int VEHICLE_TYPE_CAR = 2; - public const int VEHICLE_TYPE_BOAT = 3; - public const int VEHICLE_TYPE_AIRPLANE = 4; - public const int VEHICLE_TYPE_BALLOON = 5; - public const int VEHICLE_LINEAR_FRICTION_TIMESCALE = 16; - public const int VEHICLE_ANGULAR_FRICTION_TIMESCALE = 17; - public const int VEHICLE_LINEAR_MOTOR_DIRECTION = 18; - public const int VEHICLE_LINEAR_MOTOR_OFFSET = 20; - public const int VEHICLE_ANGULAR_MOTOR_DIRECTION = 19; - public const int VEHICLE_HOVER_HEIGHT = 24; - public const int VEHICLE_HOVER_EFFICIENCY = 25; - public const int VEHICLE_HOVER_TIMESCALE = 26; - public const int VEHICLE_BUOYANCY = 27; - public const int VEHICLE_LINEAR_DEFLECTION_EFFICIENCY = 28; - public const int VEHICLE_LINEAR_DEFLECTION_TIMESCALE = 29; - public const int VEHICLE_LINEAR_MOTOR_TIMESCALE = 30; - public const int VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE = 31; - public const int VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY = 32; - public const int VEHICLE_ANGULAR_DEFLECTION_TIMESCALE = 33; - public const int VEHICLE_ANGULAR_MOTOR_TIMESCALE = 34; - public const int VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE = 35; - public const int VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY = 36; - public const int VEHICLE_VERTICAL_ATTRACTION_TIMESCALE = 37; - public const int VEHICLE_BANKING_EFFICIENCY = 38; - public const int VEHICLE_BANKING_MIX = 39; - public const int VEHICLE_BANKING_TIMESCALE = 40; - public const int VEHICLE_REFERENCE_FRAME = 44; - public const int VEHICLE_FLAG_NO_DEFLECTION_UP = 1; - public const int VEHICLE_FLAG_LIMIT_ROLL_ONLY = 2; - public const int VEHICLE_FLAG_HOVER_WATER_ONLY = 4; - public const int VEHICLE_FLAG_HOVER_TERRAIN_ONLY = 8; - public const int VEHICLE_FLAG_HOVER_GLOBAL_HEIGHT = 16; - public const int VEHICLE_FLAG_HOVER_UP_ONLY = 32; - public const int VEHICLE_FLAG_LIMIT_MOTOR_UP = 64; - public const int VEHICLE_FLAG_MOUSELOOK_STEER = 128; - public const int VEHICLE_FLAG_MOUSELOOK_BANK = 256; - public const int VEHICLE_FLAG_CAMERA_DECOUPLED = 512; - - public const int INVENTORY_ALL = -1; - public const int INVENTORY_NONE = -1; - public const int INVENTORY_TEXTURE = 0; - public const int INVENTORY_SOUND = 1; - public const int INVENTORY_LANDMARK = 3; - public const int INVENTORY_CLOTHING = 5; - public const int INVENTORY_OBJECT = 6; - public const int INVENTORY_NOTECARD = 7; - public const int INVENTORY_SCRIPT = 10; - public const int INVENTORY_BODYPART = 13; - public const int INVENTORY_ANIMATION = 20; - public const int INVENTORY_GESTURE = 21; - - public const int ATTACH_CHEST = 1; - public const int ATTACH_HEAD = 2; - public const int ATTACH_LSHOULDER = 3; - public const int ATTACH_RSHOULDER = 4; - public const int ATTACH_LHAND = 5; - public const int ATTACH_RHAND = 6; - public const int ATTACH_LFOOT = 7; - public const int ATTACH_RFOOT = 8; - public const int ATTACH_BACK = 9; - public const int ATTACH_PELVIS = 10; - public const int ATTACH_MOUTH = 11; - public const int ATTACH_CHIN = 12; - public const int ATTACH_LEAR = 13; - public const int ATTACH_REAR = 14; - public const int ATTACH_LEYE = 15; - public const int ATTACH_REYE = 16; - public const int ATTACH_NOSE = 17; - public const int ATTACH_RUARM = 18; - public const int ATTACH_RLARM = 19; - public const int ATTACH_LUARM = 20; - public const int ATTACH_LLARM = 21; - public const int ATTACH_RHIP = 22; - public const int ATTACH_RULEG = 23; - public const int ATTACH_RLLEG = 24; - public const int ATTACH_LHIP = 25; - public const int ATTACH_LULEG = 26; - public const int ATTACH_LLLEG = 27; - public const int ATTACH_BELLY = 28; - public const int ATTACH_RPEC = 29; - public const int ATTACH_LPEC = 30; - - public const int LAND_LEVEL = 0; - public const int LAND_RAISE = 1; - public const int LAND_LOWER = 2; - public const int LAND_SMOOTH = 3; - public const int LAND_NOISE = 4; - public const int LAND_REVERT = 5; - public const int LAND_SMALL_BRUSH = 1; - public const int LAND_MEDIUM_BRUSH = 2; - public const int LAND_LARGE_BRUSH = 3; - - //Agent Dataserver - public const int DATA_ONLINE = 1; - public const int DATA_NAME = 2; - public const int DATA_BORN = 3; - public const int DATA_RATING = 4; - public const int DATA_SIM_POS = 5; - public const int DATA_SIM_STATUS = 6; - public const int DATA_SIM_RATING = 7; - public const int DATA_PAYINFO = 8; - - public const int ANIM_ON = 1; - public const int LOOP = 2; - public const int REVERSE = 4; - public const int PING_PONG = 8; - public const int SMOOTH = 16; - public const int ROTATE = 32; - public const int SCALE = 64; - public const int ALL_SIDES = -1; - public const int LINK_SET = -1; - public const int LINK_ROOT = 1; - public const int LINK_ALL_OTHERS = -2; - public const int LINK_ALL_CHILDREN = -3; - public const int LINK_THIS = -4; - public const int CHANGED_INVENTORY = 1; - public const int CHANGED_COLOR = 2; - public const int CHANGED_SHAPE = 4; - public const int CHANGED_SCALE = 8; - public const int CHANGED_TEXTURE = 16; - public const int CHANGED_LINK = 32; - public const int CHANGED_ALLOWED_DROP = 64; - public const int CHANGED_OWNER = 128; - public const int CHANGED_REGION_RESTART = 256; - public const int TYPE_INVALID = 0; - public const int TYPE_INTEGER = 1; - public const int TYPE_double = 2; - public const int TYPE_STRING = 3; - public const int TYPE_KEY = 4; - public const int TYPE_VECTOR = 5; - public const int TYPE_ROTATION = 6; - - //XML RPC Remote Data Channel - public const int REMOTE_DATA_CHANNEL = 1; - public const int REMOTE_DATA_REQUEST = 2; - public const int REMOTE_DATA_REPLY = 3; - - //llHTTPRequest - public const int HTTP_METHOD = 0; - public const int HTTP_MIMETYPE = 1; - public const int HTTP_BODY_MAXLENGTH = 2; - public const int HTTP_VERIFY_CERT = 3; - - public const int PRIM_MATERIAL = 2; - public const int PRIM_PHYSICS = 3; - public const int PRIM_TEMP_ON_REZ = 4; - public const int PRIM_PHANTOM = 5; - public const int PRIM_POSITION = 6; - public const int PRIM_SIZE = 7; - public const int PRIM_ROTATION = 8; - public const int PRIM_TYPE = 9; - public const int PRIM_TEXTURE = 17; - public const int PRIM_COLOR = 18; - public const int PRIM_BUMP_SHINY = 19; - public const int PRIM_FULLBRIGHT = 20; - public const int PRIM_FLEXIBLE = 21; - public const int PRIM_TEXGEN = 22; - public const int PRIM_CAST_SHADOWS = 24; // Not implemented, here for completeness sake - public const int PRIM_POINT_LIGHT = 23; // Huh? - public const int PRIM_TEXGEN_DEFAULT = 0; - public const int PRIM_TEXGEN_PLANAR = 1; - - public const int PRIM_TYPE_BOX = 0; - public const int PRIM_TYPE_CYLINDER = 1; - public const int PRIM_TYPE_PRISM = 2; - public const int PRIM_TYPE_SPHERE = 3; - public const int PRIM_TYPE_TORUS = 4; - public const int PRIM_TYPE_TUBE = 5; - public const int PRIM_TYPE_RING = 6; - public const int PRIM_TYPE_SCULPT = 7; - - public const int PRIM_HOLE_DEFAULT = 0; - public const int PRIM_HOLE_CIRCLE = 16; - public const int PRIM_HOLE_SQUARE = 32; - public const int PRIM_HOLE_TRIANGLE = 48; - - public const int PRIM_MATERIAL_STONE = 0; - public const int PRIM_MATERIAL_METAL = 1; - public const int PRIM_MATERIAL_GLASS = 2; - public const int PRIM_MATERIAL_WOOD = 3; - public const int PRIM_MATERIAL_FLESH = 4; - public const int PRIM_MATERIAL_PLASTIC = 5; - public const int PRIM_MATERIAL_RUBBER = 6; - public const int PRIM_MATERIAL_LIGHT = 7; - - public const int PRIM_SHINY_NONE = 0; - public const int PRIM_SHINY_LOW = 1; - public const int PRIM_SHINY_MEDIUM = 2; - public const int PRIM_SHINY_HIGH = 3; - public const int PRIM_BUMP_NONE = 0; - public const int PRIM_BUMP_BRIGHT = 1; - public const int PRIM_BUMP_DARK = 2; - public const int PRIM_BUMP_WOOD = 3; - public const int PRIM_BUMP_BARK = 4; - public const int PRIM_BUMP_BRICKS = 5; - public const int PRIM_BUMP_CHECKER = 6; - public const int PRIM_BUMP_CONCRETE = 7; - public const int PRIM_BUMP_TILE = 8; - public const int PRIM_BUMP_STONE = 9; - public const int PRIM_BUMP_DISKS = 10; - public const int PRIM_BUMP_GRAVEL = 11; - public const int PRIM_BUMP_BLOBS = 12; - public const int PRIM_BUMP_SIDING = 13; - public const int PRIM_BUMP_LARGETILE = 14; - public const int PRIM_BUMP_STUCCO = 15; - public const int PRIM_BUMP_SUCTION = 16; - public const int PRIM_BUMP_WEAVE = 17; - - public const int PRIM_SCULPT_TYPE_SPHERE = 1; - public const int PRIM_SCULPT_TYPE_TORUS = 2; - public const int PRIM_SCULPT_TYPE_PLANE = 3; - public const int PRIM_SCULPT_TYPE_CYLINDER = 4; - - public const int MASK_BASE = 0; - public const int MASK_OWNER = 1; - public const int MASK_GROUP = 2; - public const int MASK_EVERYONE = 3; - public const int MASK_NEXT = 4; - - public const int PERM_TRANSFER = 8192; - public const int PERM_MODIFY = 16384; - public const int PERM_COPY = 32768; - public const int PERM_MOVE = 524288; - public const int PERM_ALL = 2147483647; - - public const int PARCEL_MEDIA_COMMAND_STOP = 0; - public const int PARCEL_MEDIA_COMMAND_PAUSE = 1; - public const int PARCEL_MEDIA_COMMAND_PLAY = 2; - public const int PARCEL_MEDIA_COMMAND_LOOP = 3; - public const int PARCEL_MEDIA_COMMAND_TEXTURE = 4; - public const int PARCEL_MEDIA_COMMAND_URL = 5; - public const int PARCEL_MEDIA_COMMAND_TIME = 6; - public const int PARCEL_MEDIA_COMMAND_AGENT = 7; - public const int PARCEL_MEDIA_COMMAND_UNLOAD = 8; - public const int PARCEL_MEDIA_COMMAND_AUTO_ALIGN = 9; - - public const int PAY_HIDE = -1; - public const int PAY_DEFAULT = -2; - - public const string NULL_KEY = "00000000-0000-0000-0000-000000000000"; - public const string EOF = "\n\n\n"; - public const double PI = 3.14159274f; - public const double TWO_PI = 6.28318548f; - public const double PI_BY_TWO = 1.57079637f; - public const double DEG_TO_RAD = 0.01745329238f; - public const double RAD_TO_DEG = 57.29578f; - public const double SQRT2 = 1.414213538f; - public const int STRING_TRIM_HEAD = 1; - public const int STRING_TRIM_TAIL = 2; - public const int STRING_TRIM = 3; - public const int LIST_STAT_RANGE = 0; - public const int LIST_STAT_MIN = 1; - public const int LIST_STAT_MAX = 2; - public const int LIST_STAT_MEAN = 3; - public const int LIST_STAT_MEDIAN = 4; - public const int LIST_STAT_STD_DEV = 5; - public const int LIST_STAT_SUM = 6; - public const int LIST_STAT_SUM_SQUARES = 7; - public const int LIST_STAT_NUM_COUNT = 8; - public const int LIST_STAT_GEOMETRIC_MEAN = 9; - public const int LIST_STAT_HARMONIC_MEAN = 100; - - //ParcelPrim Categories - public const int PARCEL_COUNT_TOTAL = 0; - public const int PARCEL_COUNT_OWNER = 1; - public const int PARCEL_COUNT_GROUP = 2; - public const int PARCEL_COUNT_OTHER = 3; - public const int PARCEL_COUNT_SELECTED = 4; - public const int PARCEL_COUNT_TEMP = 5; - - public const int DEBUG_CHANNEL = 0x7FFFFFFF; - public const int PUBLIC_CHANNEL = 0x00000000; - - public const int OBJECT_NAME = 1; - public const int OBJECT_DESC = 2; - public const int OBJECT_POS = 3; - public const int OBJECT_ROT = 4; - public const int OBJECT_VELOCITY = 5; - public const int OBJECT_OWNER = 6; - public const int OBJECT_GROUP = 7; - public const int OBJECT_CREATOR = 8; - - // Can not be public const? - public vector ZERO_VECTOR = new vector(0.0, 0.0, 0.0); - public rotation ZERO_ROTATION = new rotation(0.0, 0, 0.0, 1.0); - - - // - // OSSL - // - // FIXME: Refactor so we don't need to pull the script engine - // into the app domain - // - - public void osSetRegionWaterHeight(double height) - { - m_OSSL_Functions.osSetRegionWaterHeight(height); - } - - public double osList2Double(LSL_Types.list src, int index) - { - return m_OSSL_Functions.osList2Double(src, index); - } - - public string osSetDynamicTextureURL(string dynamicID, string contentType, string url, string extraParams, - int timer) - { - return m_OSSL_Functions.osSetDynamicTextureURL(dynamicID, contentType, url, extraParams, timer); - } - - public string osSetDynamicTextureData(string dynamicID, string contentType, string data, string extraParams, - int timer) - { - return m_OSSL_Functions.osSetDynamicTextureData(dynamicID, contentType, data, extraParams, timer); - } - - public string osSetDynamicTextureURLBlend(string dynamicID, string contentType, string url, string extraParams, - int timer, int alpha) - { - return m_OSSL_Functions.osSetDynamicTextureURLBlend(dynamicID, contentType, url, extraParams, timer, alpha); - } - - public string osSetDynamicTextureDataBlend(string dynamicID, string contentType, string data, string extraParams, - int timer, int alpha) - { - return m_OSSL_Functions.osSetDynamicTextureDataBlend(dynamicID, contentType, data, extraParams, timer, alpha); - } - - public double osTerrainGetHeight(int x, int y) - { - return m_OSSL_Functions.osTerrainGetHeight(x, y); - } - - public int osTerrainSetHeight(int x, int y, double val) - { - return m_OSSL_Functions.osTerrainSetHeight(x, y, val); - } - - public int osRegionRestart(double seconds) - { - return m_OSSL_Functions.osRegionRestart(seconds); - } - - public void osRegionNotice(string msg) - { - m_OSSL_Functions.osRegionNotice(msg); - } - - public bool osConsoleCommand(string Command) - { - return m_OSSL_Functions.osConsoleCommand(Command); - } - - public void osSetParcelMediaURL(string url) - { - m_OSSL_Functions.osSetParcelMediaURL(url); - } - - public void osSetPrimFloatOnWater(int floatYN) - { - m_OSSL_Functions.osSetPrimFloatOnWater(floatYN); - } - - // Animation Functions - - public void osAvatarPlayAnimation(string avatar, string animation) - { - m_OSSL_Functions.osAvatarPlayAnimation(avatar, animation); - } - - public void osAvatarStopAnimation(string avatar, string animation) - { - m_OSSL_Functions.osAvatarStopAnimation(avatar, animation); - } - - - //Texture Draw functions - - public string osMovePen(string drawList, int x, int y) - { - return m_OSSL_Functions.osMovePen(drawList, x, y); - } - - public string osDrawLine(string drawList, int startX, int startY, int endX, int endY) - { - return m_OSSL_Functions.osDrawLine(drawList, startX, startY, endX, endY); - } - - public string osDrawLine(string drawList, int endX, int endY) - { - return m_OSSL_Functions.osDrawLine(drawList, endX, endY); - } - - public string osDrawText(string drawList, string text) - { - return m_OSSL_Functions.osDrawText(drawList, text); - } - - public string osDrawEllipse(string drawList, int width, int height) - { - return m_OSSL_Functions.osDrawEllipse(drawList, width, height); - } - - public string osDrawRectangle(string drawList, int width, int height) - { - return m_OSSL_Functions.osDrawRectangle(drawList, width, height); - } - - public string osDrawFilledRectangle(string drawList, int width, int height) - { - return m_OSSL_Functions.osDrawFilledRectangle(drawList, width, height); - } - - public string osSetFontSize(string drawList, int fontSize) - { - return m_OSSL_Functions.osSetFontSize(drawList, fontSize); - } - - public string osSetPenSize(string drawList, int penSize) - { - return m_OSSL_Functions.osSetPenSize(drawList, penSize); - } - - public string osSetPenColour(string drawList, string colour) - { - return m_OSSL_Functions.osSetPenColour(drawList, colour); - } - - public string osDrawImage(string drawList, int width, int height, string imageUrl) - { - return m_OSSL_Functions.osDrawImage(drawList, width, height, imageUrl); - } - public void osSetStateEvents(int events) - { - m_OSSL_Functions.osSetStateEvents(events); - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/Script/ILSL_ScriptCommands.cs b/OpenSim/Region/ScriptEngine/XEngine/Script/ILSL_ScriptCommands.cs deleted file mode 100644 index 9e8965c..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/Script/ILSL_ScriptCommands.cs +++ /dev/null @@ -1,653 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using OpenSim.Region.Environment.Interfaces; - -namespace OpenSim.Region.ScriptEngine.XEngine.Script -{ - public interface ILSL_ScriptCommands - { - // Interface used for loading and executing scripts - - string State { get; set ; } - - void state(string newState); - - ICommander GetCommander(string name); - - void llSay(int channelID, string text); - double llSin(double f); - double llCos(double f); - double llTan(double f); - double llAtan2(double x, double y); - double llSqrt(double f); - double llPow(double fbase, double fexponent); - LSL_Types.LSLInteger llAbs(int i); - double llFabs(double f); - double llFrand(double mag); - LSL_Types.LSLInteger llFloor(double f); - LSL_Types.LSLInteger llCeil(double f); - LSL_Types.LSLInteger llRound(double f); - double llVecMag(LSL_Types.Vector3 v); - LSL_Types.Vector3 llVecNorm(LSL_Types.Vector3 v); - double llVecDist(LSL_Types.Vector3 a, LSL_Types.Vector3 b); - LSL_Types.Vector3 llRot2Euler(LSL_Types.Quaternion r); - LSL_Types.Quaternion llEuler2Rot(LSL_Types.Vector3 v); - LSL_Types.Quaternion llAxes2Rot(LSL_Types.Vector3 fwd, LSL_Types.Vector3 left, LSL_Types.Vector3 up); - LSL_Types.Vector3 llRot2Fwd(LSL_Types.Quaternion r); - LSL_Types.Vector3 llRot2Left(LSL_Types.Quaternion r); - LSL_Types.Vector3 llRot2Up(LSL_Types.Quaternion r); - LSL_Types.Quaternion llRotBetween(LSL_Types.Vector3 start, LSL_Types.Vector3 end); - void llWhisper(int channelID, string text); - //void llSay(int channelID, string text); - void llShout(int channelID, string text); - void llRegionSay(int channelID, string text); - LSL_Types.LSLInteger llListen(int channelID, string name, string ID, string msg); - void llListenControl(int number, int active); - void llListenRemove(int number); - void llSensor(string name, string id, int type, double range, double arc); - void llSensorRepeat(string name, string id, int type, double range, double arc, double rate); - void llSensorRemove(); - string llDetectedName(int number); - string llDetectedKey(int number); - string llDetectedOwner(int number); - LSL_Types.LSLInteger llDetectedType(int number); - LSL_Types.Vector3 llDetectedPos(int number); - LSL_Types.Vector3 llDetectedVel(int number); - LSL_Types.Vector3 llDetectedGrab(int number); - LSL_Types.Quaternion llDetectedRot(int number); - LSL_Types.LSLInteger llDetectedGroup(int number); - LSL_Types.LSLInteger llDetectedLinkNumber(int number); - void llDie(); - double llGround(LSL_Types.Vector3 offset); - double llCloud(LSL_Types.Vector3 offset); - LSL_Types.Vector3 llWind(LSL_Types.Vector3 offset); - void llSetStatus(int status, int value); - LSL_Types.LSLInteger llGetStatus(int status); - void llSetScale(LSL_Types.Vector3 scale); - LSL_Types.Vector3 llGetScale(); - void llSetColor(LSL_Types.Vector3 color, int face); - double llGetAlpha(int face); - void llSetAlpha(double alpha, int face); - LSL_Types.Vector3 llGetColor(int face); - void llSetTexture(string texture, int face); - void llScaleTexture(double u, double v, int face); - void llOffsetTexture(double u, double v, int face); - void llRotateTexture(double rotation, int face); - string llGetTexture(int face); - void llSetPos(LSL_Types.Vector3 pos); - - //wiki: vector llGetPos() - LSL_Types.Vector3 llGetPos(); - //wiki: vector llGetLocalPos() - LSL_Types.Vector3 llGetLocalPos(); - //wiki: llSetRot(rotation rot) - void llSetRot(LSL_Types.Quaternion rot); - //wiki: rotation llGetRot() - LSL_Types.Quaternion llGetRot(); - //wiki: rotation llGetLocalRot() - LSL_Types.Quaternion llGetLocalRot(); - //wiki: llSetForce(vector force, integer local) - void llSetForce(LSL_Types.Vector3 force, int local); - //wiki: vector llGetForce() - LSL_Types.Vector3 llGetForce(); - //wiki: integer llTarget(vector position, double range) - LSL_Types.LSLInteger llTarget(LSL_Types.Vector3 position, double range); - //wiki: llTargetRemove(integer number) - void llTargetRemove(int number); - //wiki: integer llRotTarget(rotation rot, double error) - LSL_Types.LSLInteger llRotTarget(LSL_Types.Quaternion rot, double error); - //wiki: integer llRotTargetRemove(integer number) - void llRotTargetRemove(int number); - //wiki: llMoveToTarget(vector target, double tau) - void llMoveToTarget(LSL_Types.Vector3 target, double tau); - //wiki: llStopMoveToTarget() - void llStopMoveToTarget(); - //wiki: llApplyImpulse(vector force, integer local) - void llApplyImpulse(LSL_Types.Vector3 force, int local); - //wiki: llapplyRotationalImpulse(vector force, integer local) - void llApplyRotationalImpulse(LSL_Types.Vector3 force, int local); - //wiki: llSetTorque(vector torque, integer local) - void llSetTorque(LSL_Types.Vector3 torque, int local); - //wiki: vector llGetTorque() - LSL_Types.Vector3 llGetTorque(); - //wiki: llSeForceAndTorque(vector force, vector torque, integer local) - void llSetForceAndTorque(LSL_Types.Vector3 force, LSL_Types.Vector3 torque, int local); - //wiki: vector llGetVel() - LSL_Types.Vector3 llGetVel(); - //wiki: vector llGetAccel() - LSL_Types.Vector3 llGetAccel(); - //wiki: vector llGetOmega() - LSL_Types.Vector3 llGetOmega(); - //wiki: double llGetTimeOfDay() - double llGetTimeOfDay(); - //wiki: double llGetWallclock() - double llGetWallclock(); - //wiki: double llGetTime() - double llGetTime(); - //wiki: llResetTime() - void llResetTime(); - //wiki: double llGetAndResetTime() - double llGetAndResetTime(); - //wiki (deprecated) llSound(string sound, double volume, integer queue, integer loop) - void llSound(); - //wiki: llPlaySound(string sound, double volume) - void llPlaySound(string sound, double volume); - //wiki: llLoopSound(string sound, double volume) - void llLoopSound(string sound, double volume); - //wiki: llLoopSoundMaster(string sound, double volume) - void llLoopSoundMaster(string sound, double volume); - //wiki: llLoopSoundSlave(string sound, double volume) - void llLoopSoundSlave(string sound, double volume); - //wiki llPlaySoundSlave(string sound, double volume) - void llPlaySoundSlave(string sound, double volume); - //wiki: llTriggerSound(string sound, double volume) - void llTriggerSound(string sound, double volume); - //wiki: llStopSound() - void llStopSound(); - //wiki: llPreloadSound(string sound) - void llPreloadSound(string sound); - //wiki: string llGetSubString(string src, integer start, integer end) - string llGetSubString(string src, int start, int end); - //wiki: string llDeleteSubString(string src, integer start, integer end) - string llDeleteSubString(string src, int start, int end); - //wiki string llInsertString(string dst, integer position, string src) - string llInsertString(string dst, int position, string src); - //wiki: string llToUpper(string source) - string llToUpper(string source); - //wiki: string llToLower(string source) - string llToLower(string source); - //wiki: integer llGiveMoney(key destination, integer amount) - LSL_Types.LSLInteger llGiveMoney(string destination, int amount); - //wiki: (deprecated) - void llMakeExplosion(); - //wiki: (deprecated) - void llMakeFountain(); - //wiki: (deprecated) - void llMakeSmoke(); - //wiki: (deprecated) - void llMakeFire(); - //wiki: llRezObject(string inventory, vector pos, vector rel, rotation rot, integer param) - void llRezObject(string inventory, LSL_Types.Vector3 pos, LSL_Types.Vector3 vel, LSL_Types.Quaternion rot, int param); - //wiki: llLookAt(vector target, double strength, double damping) - void llLookAt(LSL_Types.Vector3 target, double strength, double damping); - //wiki: llStopLookAt() - void llStopLookAt(); - //wiki: llSetTimerEvent(double sec) - void llSetTimerEvent(double sec); - //wiki: llSleep(double sec) - void llSleep(double sec); - //wiki: double llGetMass() - double llGetMass(); - //wiki: llCollisionFilter(string name, key id, integer accept) - void llCollisionFilter(string name, string id, int accept); - //wiki: llTakeControls(integer controls, integer accept, integer pass_on) - void llTakeControls(int controls, int accept, int pass_on); - //wiki: llReleaseControls() - void llReleaseControls(); - //wiki: llAttachToAvatar(integer attachment) - void llAttachToAvatar(int attachment); - //wiki: llDetachFromAvatar() - void llDetachFromAvatar(); - //wiki: (deprecated) llTakeCamera() - void llTakeCamera(); - //wiki: (deprecated) llReleaseCamera() - void llReleaseCamera(); - //wiki: key llGetOwner() - string llGetOwner(); - //wiki: llInstantMessage(key user, string message) - void llInstantMessage(string user, string message); - //wiki: llEmail(string address, string subject, string message) - void llEmail(string address, string subject, string message); - //wiki: llGetNextEmail(string address, string subject) - void llGetNextEmail(string address, string subject); - //wiki: key llGetKey() - string llGetKey(); - //wiki: llSetBuoyancy(double buoyancy) - void llSetBuoyancy(double buoyancy); - //wiki: llSetHoverHeight(double height, integer water, double tau) - void llSetHoverHeight(double height, int water, double tau); - //wiki: llStopHover - void llStopHover(); - //wiki: llMinEventDelay(double delay) - void llMinEventDelay(double delay); - //wiki: (deprecated) llSoundPreload() - void llSoundPreload(); - //wiki: llRotLookAt(rotation target, double strength, double damping) - void llRotLookAt(LSL_Types.Quaternion target, double strength, double damping); - //wiki: integer llStringLength(string str) - LSL_Types.LSLInteger llStringLength(string str); - //wiki: llStartAnimation(string anim) - void llStartAnimation(string anim); - //wiki: llStopAnimation(string anim) - void llStopAnimation(string anim); - //wiki: (deprecated) llPointAt - void llPointAt(); - //wiki: (deprecated) llStopPointAt - void llStopPointAt(); - //wiki: llTargetOmega(vector axis, double spinrate, double gain) - void llTargetOmega(LSL_Types.Vector3 axis, double spinrate, double gain); - //wiki: integer llGetStartParameter() - LSL_Types.LSLInteger llGetStartParameter(); - //wiki: llGodLikeRezObject(key inventory, vector pos) - void llGodLikeRezObject(string inventory, LSL_Types.Vector3 pos); - //wiki: llRequestPermissions(key agent, integer perm) - void llRequestPermissions(string agent, int perm); - //wiki: key llGetPermissionsKey() - string llGetPermissionsKey(); - //wiki: integer llGetPermissions() - LSL_Types.LSLInteger llGetPermissions(); - //wiki integer llGetLinkNumber() - LSL_Types.LSLInteger llGetLinkNumber(); - //wiki: llSetLinkColor(integer linknumber, vector color, integer face) - void llSetLinkColor(int linknumber, LSL_Types.Vector3 color, int face); - //wiki: llCreateLink(key target, integer parent) - void llCreateLink(string target, int parent); - //wiki: llBreakLink(integer linknum) - void llBreakLink(int linknum); - //wiki: llBreakAllLinks() - void llBreakAllLinks(); - //wiki: key llGetLinkKey(integer linknum) - string llGetLinkKey(int linknum); - //wiki: llGetLinkName(integer linknum) - string llGetLinkName(int linknum); - //wiki: integer llGetInventoryNumber(integer type) - LSL_Types.LSLInteger llGetInventoryNumber(int type); - //wiki: string llGetInventoryName(integer type, integer number) - string llGetInventoryName(int type, int number); - //wiki: llSetScriptState(string name, integer run) - void llSetScriptState(string name, int run); - //wiki: double llGetEnergy() - double llGetEnergy(); - //wiki: llGiveInventory(key destination, string inventory) - void llGiveInventory(string destination, string inventory); - //wiki: llRemoveInventory(string item) - void llRemoveInventory(string item); - //wiki: llSetText(string text, vector color, double alpha) - void llSetText(string text, LSL_Types.Vector3 color, double alpha); - //wiki: double llWater(vector offset) - double llWater(LSL_Types.Vector3 offset); - //wiki: llPassTouches(integer pass) - void llPassTouches(int pass); - //wiki: key llRequestAgentData(key id, integer data) - string llRequestAgentData(string id, int data); - //wiki: key llRequestInventoryData(string name) - string llRequestInventoryData(string name); - //wiki: llSetDamage(double damage) - void llSetDamage(double damage); - //wiki: llTeleportAgentHome(key agent) - void llTeleportAgentHome(string agent); - //wiki: llModifyLand(integer action, integer brush) - void llModifyLand(int action, int brush); - //wiki: llCollisionSound(string impact_sound, double impact_volume) - void llCollisionSound(string impact_sound, double impact_volume); - //wiki: llCollisionSprite(string impact_sprite) - void llCollisionSprite(string impact_sprite); - //wiki: string llGetAnimation(key id) - string llGetAnimation(string id); - //wiki: llResetScript() - void llResetScript(); - //wiki: llMessageLinked(integer linknum, integer num, string str, key id) - void llMessageLinked(int linknum, int num, string str, string id); - //wiki: llPushObject(key target, vector impulse, vector ang_impulse, integer local) - void llPushObject(string target, LSL_Types.Vector3 impulse, LSL_Types.Vector3 ang_impulse, int local); - //wiki: llPassCollisions(integer pass) - void llPassCollisions(int pass); - //wiki: string llGetScriptName() - string llGetScriptName(); - //wiki: integer llGetNumberOfSides() - LSL_Types.LSLInteger llGetNumberOfSides(); - //wiki: rotation llAxisAngle2Rot(vector axis, double angle) - LSL_Types.Quaternion llAxisAngle2Rot(LSL_Types.Vector3 axis, double angle); - //wiki: vector llRot2Axis(rotation rot) - LSL_Types.Vector3 llRot2Axis(LSL_Types.Quaternion rot); - //wiki: double llRot2Angle(rotation rot); - double llRot2Angle(LSL_Types.Quaternion rot); - //wiki: double llAcos(double val) - double llAcos(double val); - //wiki: double llAsin(double val) - double llAsin(double val); - //wiki: double llAngleBetween(rotation a, rotation b) - double llAngleBetween(LSL_Types.Quaternion a, LSL_Types.Quaternion b); - //wiki: string llGetInventoryKey(string name) - string llGetInventoryKey(string name); - //wiki: llAllowInventoryDrop(integer add) - void llAllowInventoryDrop(int add); - //wiki: vector llGetSunDirection() - LSL_Types.Vector3 llGetSunDirection(); - //wiki: vector llGetTextureOffset(integer face) - LSL_Types.Vector3 llGetTextureOffset(int face); - //wiki: vector llGetTextureScale(integer side) - LSL_Types.Vector3 llGetTextureScale(int side); - //wiki: double llGetTextureRot(integer side) - double llGetTextureRot(int side); - //wiki: integer llSubStringIndex(string source, string pattern) - LSL_Types.LSLInteger llSubStringIndex(string source, string pattern); - //wiki: key llGetOwnerKey(key id) - string llGetOwnerKey(string id); - //wiki: vector llGetCenterOfMass() - LSL_Types.Vector3 llGetCenterOfMass(); - //wiki: list llListSort(list src, integer stride, integer ascending) - LSL_Types.list llListSort(LSL_Types.list src, int stride, int ascending); - //integer llGetListLength(list src) - LSL_Types.LSLInteger llGetListLength(LSL_Types.list src); - //wiki: integer llList2Integer(list src, integer index) - LSL_Types.LSLInteger llList2Integer(LSL_Types.list src, int index); - //wiki: double llList2double(list src, integer index) - double llList2Float(LSL_Types.list src, int index); - //wiki: string llList2String(list src, integer index) - string llList2String(LSL_Types.list src, int index); - //wiki: key llList2Key(list src, integer index) - string llList2Key(LSL_Types.list src, int index); - //wiki: vector llList2Vector(list src, integer index) - LSL_Types.Vector3 llList2Vector(LSL_Types.list src, int index); - //wiki rotation llList2Rot(list src, integer index) - LSL_Types.Quaternion llList2Rot(LSL_Types.list src, int index); - //wiki: list llList2List(list src, integer start, integer end) - LSL_Types.list llList2List(LSL_Types.list src, int start, int end); - //wiki: llDeleteSubList(list src, integer start, integer end) - LSL_Types.list llDeleteSubList(LSL_Types.list src, int start, int end); - //wiki: integer llGetListEntryType(list src, integer index) - LSL_Types.LSLInteger llGetListEntryType(LSL_Types.list src, int index); - //wiki: string llList2CSV(list src) - string llList2CSV(LSL_Types.list src); - //wiki: list llCSV2List(string src) - LSL_Types.list llCSV2List(string src); - //wiki: list llListRandomize(list src, integer stride) - LSL_Types.list llListRandomize(LSL_Types.list src, int stride); - //wiki: list llList2ListStrided(list src, integer start, integer end, integer stride) - LSL_Types.list llList2ListStrided(LSL_Types.list src, int start, int end, int stride); - //wiki: vector llGetRegionCorner() - LSL_Types.Vector3 llGetRegionCorner(); - //wiki: list llListInsertList(list dest, list src, integer start) - LSL_Types.list llListInsertList(LSL_Types.list dest, LSL_Types.list src, int start); - //wiki: integer llListFindList(list src, list test) - LSL_Types.LSLInteger llListFindList(LSL_Types.list src, LSL_Types.list test); - //wiki: string llGetObjectName() - string llGetObjectName(); - //wiki: llSetObjectName(string name) - void llSetObjectName(string name); - //wiki: string llGetDate() - string llGetDate(); - //wiki: integer llEdgeOfWorld(vector pos, vector dir) - LSL_Types.LSLInteger llEdgeOfWorld(LSL_Types.Vector3 pos, LSL_Types.Vector3 dir); - //wiki: integer llGetAgentInfo(key id) - LSL_Types.LSLInteger llGetAgentInfo(string id); - //wiki: llAdjustSoundVolume(double volume) - void llAdjustSoundVolume(double volume); - //wiki: llSetSoundQueueing(integer queue) - void llSetSoundQueueing(int queue); - //wiki: llSetSoundRadius(double radius) - void llSetSoundRadius(double radius); - //wiki: string llKey2Name(key id) - string llKey2Name(string id); - //wiki: llSetTextureAnim(integer mode, integer face, integer sizex, integer sizey, double start, double length, double rate) - void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate); - //wiki: llTriggerSoundLimited(string sound, double volume, vector top_north_east, vector bottom_south_west) - void llTriggerSoundLimited(string sound, double volume, LSL_Types.Vector3 top_north_east, - LSL_Types.Vector3 bottom_south_west); - - //wiki: llEjectFromLand(key pest) - void llEjectFromLand(string pest); - LSL_Types.list llParseString2List(string str, LSL_Types.list separators, LSL_Types.list spacers); - //wiki: integer llOverMyLand(key id) - LSL_Types.LSLInteger llOverMyLand(string id); - //wiki: key llGetLandOwnerAt(vector pos) - string llGetLandOwnerAt(LSL_Types.Vector3 pos); - //wiki: key llGetNotecardLine(string name, integer line) - string llGetNotecardLine(string name, int line); - //wiki: vector llGetAgentSize(key id) - LSL_Types.Vector3 llGetAgentSize(string id); - //wiki: integer llSameGroup(key agent) - LSL_Types.LSLInteger llSameGroup(string agent); - //wiki: llUnSit(key id) - void llUnSit(string id); - //wiki: vector llGroundSlope(vector offset) - LSL_Types.Vector3 llGroundSlope(LSL_Types.Vector3 offset); - //wiki: vector llGroundNormal(vector offset) - LSL_Types.Vector3 llGroundNormal(LSL_Types.Vector3 offset); - //wiki: vector llGroundContour(vector offset) - LSL_Types.Vector3 llGroundContour(LSL_Types.Vector3 offset); - //wiki: integer llGetAttached() - LSL_Types.LSLInteger llGetAttached(); - //wiki: integer llGetFreeMemory() - LSL_Types.LSLInteger llGetFreeMemory(); - //wiki: string llGetRegionName() - string llGetRegionName(); - //wiki: double llGetRegionTimeDilation() - double llGetRegionTimeDilation(); - //wiki: double llGetRegionFPS() - double llGetRegionFPS(); - //wiki: llParticleSystem(List rules - void llParticleSystem(LSL_Types.list rules); - //wiki: llGroundRepel(double height, integer water, double tau) - void llGroundRepel(double height, int water, double tau); - //wiki: llGiveInventoryList(string destination, string category, LSL_Types.list inventory) - void llGiveInventoryList(string destination, string category, LSL_Types.list inventory); - //wiki: llSetVehicleType(integer type) - void llSetVehicleType(int type); - //wiki: llSetVehicledoubleParam(integer param, double value) - void llSetVehicledoubleParam(int param, double value); - // wiki: llSetVehicleFloatParam(integer param, float value) - void llSetVehicleFloatParam(int param, float value); - //wiki: llSetVehicleVectorParam(integer param, vector vec) - void llSetVehicleVectorParam(int param, LSL_Types.Vector3 vec); - //wiki: llSetVehicleRotationParam(integer param, rotation rot) - void llSetVehicleRotationParam(int param, LSL_Types.Quaternion rot); - //wiki: llSetVehicleFlags(integer flags) - void llSetVehicleFlags(int flags); - //wiki: llRemoveVehicleFlags(integer flags) - void llRemoveVehicleFlags(int flags); - //wiki: llSitTarget(vector offset, rotation rot) - void llSitTarget(LSL_Types.Vector3 offset, LSL_Types.Quaternion rot); - //wiki key llAvatarOnSitTarget() - string llAvatarOnSitTarget(); - //wiki: llAddToLandPassList(key avatar, double hours) - void llAddToLandPassList(string avatar, double hours); - //wiki: llSetTouchText(string text) - void llSetTouchText(string text); - //wiki: llSetSitText(string text) - void llSetSitText(string text); - //wiki: llSetCameraEyeOffset(vector offset) - void llSetCameraEyeOffset(LSL_Types.Vector3 offset); - //wiki: llSeteCameraAtOffset(vector offset) - void llSetCameraAtOffset(LSL_Types.Vector3 offset); - // - string llDumpList2String(LSL_Types.list src, string seperator); - //wiki: integer llScriptDanger(vector pos) - LSL_Types.LSLInteger llScriptDanger(LSL_Types.Vector3 pos); - //wiki: llDialog(key avatar, string message, list buttons, integer chat_channel) - void llDialog(string avatar, string message, LSL_Types.list buttons, int chat_channel); - //wiki: llVolumeDetect(integer detect) - void llVolumeDetect(int detect); - //wiki: llResetOtherScript(string name) - void llResetOtherScript(string name); - //wiki: integer llGetScriptState(string name) - LSL_Types.LSLInteger llGetScriptState(string name); - //wiki: (deprecated) - void llRemoteLoadScript(); - //wiki: llSetRemoteScriptAccessPin(integer pin) - void llSetRemoteScriptAccessPin(int pin); - //wiki: llRemoteLoadScriptPin(key target, string name, integer pin, integer running, integer start_param) - void llRemoteLoadScriptPin(string target, string name, int pin, int running, int start_param); - //wiki: llOpenRemoteDataChannel() - void llOpenRemoteDataChannel(); - //wiki: key llSendRemoteData(key channel, string dest, integer idata, string sdata) - string llSendRemoteData(string channel, string dest, int idata, string sdata); - //wiki: llRemoteDataReply(key channel, key message_id, string sdata, integer idata) - void llRemoteDataReply(string channel, string message_id, string sdata, int idata); - //wiki: llCloseRemoteDataChannel(key channel) - void llCloseRemoteDataChannel(string channel); - //wiki: string llMD5String(string src, integer nonce) - string llMD5String(string src, int nonce); - //wiki: llSetPrimitiveParams(list rules) - void llSetPrimitiveParams(LSL_Types.list rules); - //wiki: llSetLinkPrimitiveParams(integer linknumber, list rules) - void llSetLinkPrimitiveParams(int linknumber, LSL_Types.list rules); - //wiki: string llStringToBase64(string str) - string llStringToBase64(string str); - //wiki: string llBase64ToString(string str) - string llBase64ToString(string str); - //wiki: (deprecated) - void llXorBase64Strings(); - //wiki: llRemoteDataSetRegion() - void llRemoteDataSetRegion(); - //wiki: double llLog10(double val) - double llLog10(double val); - //wiki: double llLog(double val) - double llLog(double val); - //wiki: list llGetAnimationList(key id) - LSL_Types.list llGetAnimationList(string id); - //wiki: llSetParcelMusicURL(string url) - void llSetParcelMusicURL(string url); - //wiki: vector llGetRootPosition() - LSL_Types.Vector3 llGetRootPosition(); - //wiki: rotation llGetRootRotation() - LSL_Types.Quaternion llGetRootRotation(); - //wiki: string llGetObjectDesc() - string llGetObjectDesc(); - //wiki: llSetObjectDesc(string desc) - void llSetObjectDesc(string desc); - //wiki: key llGetCreator() - string llGetCreator(); - //wiki: string llGetTimestamp() - string llGetTimestamp(); - //wiki: llSetLinkAlpha(integer linknumber, double alpha, integer face) - void llSetLinkAlpha(int linknumber, double alpha, int face); - //wiki: integer llGetNumberOfPrims() - LSL_Types.LSLInteger llGetNumberOfPrims(); - //wiki: key llGetNumberOfNotecardLines(string name) - string llGetNumberOfNotecardLines(string name); - //wiki: list llGetBoundingBox(key object) - LSL_Types.list llGetBoundingBox(string obj); - //wiki: vector llGetGeometricCenter() - LSL_Types.Vector3 llGetGeometricCenter(); - //wiki: list llGetPrimitiveParams(list rules) - LSL_Types.list llGetPrimitiveParams(LSL_Types.list rules); - //wiki: string llIntegerToBase64(integer number) - string llIntegerToBase64(int number); - //wiki integer llBase64ToInteger(string str) - LSL_Types.LSLInteger llBase64ToInteger(string str); - //wiki: double llGetGMTclock() - double llGetGMTclock(); - //wiki: string llGetSimulatorHostname() - string llGetSimulatorHostname(); - //llSetLocalRot(rotation rot) - void llSetLocalRot(LSL_Types.Quaternion rot); - //wiki: list llParseStringKeepNulls(string src, list separators, list spacers) - LSL_Types.list llParseStringKeepNulls(string src, LSL_Types.list seperators, LSL_Types.list spacers); - //wiki: llRezAtRoot(string inventory, vector position, vector velocity, rotation rot, integer param) - void llRezAtRoot(string inventory, LSL_Types.Vector3 position, LSL_Types.Vector3 velocity, - LSL_Types.Quaternion rot, int param); - - //wiki: integer llGetObjectPermMask(integer mask) - LSL_Types.LSLInteger llGetObjectPermMask(int mask); - //wiki: llSetObjectPermMask(integer mask, integer value) - void llSetObjectPermMask(int mask, int value); - //wiki integer llGetInventoryPermMask(string item, integer mask) - LSL_Types.LSLInteger llGetInventoryPermMask(string item, int mask); - //wiki: llSetInventoryPermMask(string item, integer mask, integer value) - void llSetInventoryPermMask(string item, int mask, int value); - //wiki: key llGetInventoryCreator(string item) - string llGetInventoryCreator(string item); - //wiki: llOwnerSay(string msg) - void llOwnerSay(string msg); - //wiki: key llRequestSimulatorData(string simulator, integer data) - string llRequestSimulatorData(string simulator, int data); - //wiki: llForceMouselook(integer mouselook) - void llForceMouselook(int mouselook); - //wiki: double llGetObjectMass(key id) - double llGetObjectMass(string id); - LSL_Types.list llListReplaceList(LSL_Types.list dest, LSL_Types.list src, int start, int end); - //wiki: llLoadURL(key avatar_id, string message, string url) - void llLoadURL(string avatar_id, string message, string url); - //wiki: llParcelMediaCommandList(list commandList) - void llParcelMediaCommandList(LSL_Types.list commandList); - void llParcelMediaQuery(); - //wiki integer llModPow(integer a, integer b, integer c) - LSL_Types.LSLInteger llModPow(int a, int b, int c); - //wiki: integer llGetInventoryType(string name) - LSL_Types.LSLInteger llGetInventoryType(string name); - //wiki: llSetPayPrice(integer price, list quick_pay_buttons) - void llSetPayPrice(int price, LSL_Types.list quick_pay_buttons); - //wiki: vector llGetCameraPos() - LSL_Types.Vector3 llGetCameraPos(); - //wiki rotation llGetCameraRot() - LSL_Types.Quaternion llGetCameraRot(); - //wiki: (deprecated) - void llSetPrimURL(); - //wiki: (deprecated) - void llRefreshPrimURL(); - //wiki: string llEscapeURL(string url) - string llEscapeURL(string url); - //wiki: string llUnescapeURL(string url) - string llUnescapeURL(string url); - //wiki: llMapDestination(string simname, vector pos, vector look_at) - void llMapDestination(string simname, LSL_Types.Vector3 pos, LSL_Types.Vector3 look_at); - //wiki: llAddToLandBanList(key avatar, double hours) - void llAddToLandBanList(string avatar, double hours); - //wiki: llRemoveFromLandPassList(key avatar) - void llRemoveFromLandPassList(string avatar); - //wiki: llRemoveFromLandBanList(key avatar) - void llRemoveFromLandBanList(string avatar); - //wiki: llSetCameraParams(list rules) - void llSetCameraParams(LSL_Types.list rules); - //wiki: llClearCameraParams() - void llClearCameraParams(); - //wiki: double llListStatistics(integer operation, list src) - double llListStatistics(int operation, LSL_Types.list src); - //wiki: integer llGetUnixTime() - LSL_Types.LSLInteger llGetUnixTime(); - //wiki: integer llGetParcelFlags(vector pos) - LSL_Types.LSLInteger llGetParcelFlags(LSL_Types.Vector3 pos); - //wiki: integer llGetRegionFlags() - LSL_Types.LSLInteger llGetRegionFlags(); - //wiki: string llXorBase64StringsCorrect(string str1, string str2) - string llXorBase64StringsCorrect(string str1, string str2); - string llHTTPRequest(string url, LSL_Types.list parameters, string body); - //wiki: llResetLandBanList() - void llResetLandBanList(); - //wiki: llResetLandPassList() - void llResetLandPassList(); - //wiki: integer llGetParcelPrimCount(vector pos, integer category, integer sim_wide) - LSL_Types.LSLInteger llGetParcelPrimCount(LSL_Types.Vector3 pos, int category, int sim_wide); - //wiki: list llGetParcelPrimOwners(vector pos) - LSL_Types.list llGetParcelPrimOwners(LSL_Types.Vector3 pos); - //wiki: integer llGetObjectPrimCount(key object_id) - LSL_Types.LSLInteger llGetObjectPrimCount(string object_id); - //wiki: integer llGetParcelMaxPrims(vector pos, integer sim_wide) - LSL_Types.LSLInteger llGetParcelMaxPrims(LSL_Types.Vector3 pos, int sim_wide); - //wiki: llGetParcelDetails(vector pos, list params) - LSL_Types.list llGetParcelDetails(LSL_Types.Vector3 pos, LSL_Types.list param); - //wiki: llSetLinkTexture(integer linknumber, string texture, integer face) - void llSetLinkTexture(int linknumber, string texture, int face); - //wiki: string llStringTrim(string src, int type) - string llStringTrim(string src, int type); - //wiki: LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args) - LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args); - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/Script/IOSSL_ScriptCommands.cs b/OpenSim/Region/ScriptEngine/XEngine/Script/IOSSL_ScriptCommands.cs deleted file mode 100644 index 82d4673..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/Script/IOSSL_ScriptCommands.cs +++ /dev/null @@ -1,68 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -namespace OpenSim.Region.ScriptEngine.XEngine.Script -{ - public interface IOSSL_ScriptCommands - { - //OpenSim functions - string osSetDynamicTextureURL(string dynamicID, string contentType, string url, string extraParams, int timer); - string osSetDynamicTextureURLBlend(string dynamicID, string contentType, string url, string extraParams, - int timer, int alpha); - string osSetDynamicTextureData(string dynamicID, string contentType, string data, string extraParams, int timer); - string osSetDynamicTextureDataBlend(string dynamicID, string contentType, string data, string extraParams, - int timer, int alpha); - double osTerrainGetHeight(int x, int y); - int osTerrainSetHeight(int x, int y, double val); - int osRegionRestart(double seconds); - void osRegionNotice(string msg); - bool osConsoleCommand(string Command); - void osSetParcelMediaURL(string url); - void osSetPrimFloatOnWater(int floatYN); - - // Animation commands - void osAvatarPlayAnimation(string avatar, string animation); - void osAvatarStopAnimation(string avatar, string animation); - - //texture draw functions - string osMovePen(string drawList, int x, int y); - string osDrawLine(string drawList, int startX, int startY, int endX, int endY); - string osDrawLine(string drawList, int endX, int endY); - string osDrawText(string drawList, string text); - string osDrawEllipse(string drawList, int width, int height); - string osDrawRectangle(string drawList, int width, int height); - string osDrawFilledRectangle(string drawList, int width, int height); - string osSetFontSize(string drawList, int fontSize); - string osSetPenSize(string drawList, int penSize); - string osSetPenColour(string drawList, string colour); - string osDrawImage(string drawList, int width, int height, string imageUrl); - void osSetStateEvents(int events); - - double osList2Double(LSL_Types.list src, int index); - void osSetRegionWaterHeight(double height); - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/Script/IScript.cs b/OpenSim/Region/ScriptEngine/XEngine/Script/IScript.cs deleted file mode 100644 index e5d0b33..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/Script/IScript.cs +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System.Reflection; -using System; -using System.Collections; -using System.Collections.Generic; -using OpenSim.Region.Environment.Interfaces; - -namespace OpenSim.Region.ScriptEngine.XEngine.Script -{ - public interface IScript - { - Type Start(ILSL_ScriptCommands lsl, IOSSL_ScriptCommands ossl); - - Dictionary GetVars(); - void SetVars(Dictionary vars); - void ResetVars(); - - string State { get; set; } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/Script/LSL_Types.cs b/OpenSim/Region/ScriptEngine/XEngine/Script/LSL_Types.cs deleted file mode 100644 index 8bd3d73..0000000 --- a/OpenSim/Region/ScriptEngine/XEngine/Script/LSL_Types.cs +++ /dev/null @@ -1,1512 +0,0 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSim Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -using System; -using System.Collections; -using System.Text.RegularExpressions; - -namespace OpenSim.Region.ScriptEngine.XEngine.Script -{ - [Serializable] - public partial class LSL_Types - { - // Types are kept is separate .dll to avoid having to add whatever .dll it is in it to script AppDomain - - [Serializable] - public struct Vector3 - { - public double x; - public double y; - public double z; - - #region Constructors - - public Vector3(Vector3 vector) - { - x = (float)vector.x; - y = (float)vector.y; - z = (float)vector.z; - } - - public Vector3(double X, double Y, double Z) - { - x = X; - y = Y; - z = Z; - } - - public Vector3(string str) - { - str = str.Replace('<', ' '); - str = str.Replace('>', ' '); - string[] tmps = str.Split(new Char[] { ',', '<', '>' }); - if (tmps.Length < 3) - { - x=y=z=0; - return; - } - bool res; - res = Double.TryParse(tmps[0], out x); - res = res & Double.TryParse(tmps[1], out y); - res = res & Double.TryParse(tmps[2], out z); - } - - #endregion - - #region Overriders - - public override string ToString() - { - string s=String.Format("<{0:0.000000},{1:0.000000},{2:0.000000}>", x, y, z); - return s; - } - - public static explicit operator LSLString(Vector3 vec) - { - string s=String.Format("<{0:0.000000},{1:0.000000},{2:0.000000}>", vec.x, vec.y, vec.z); - return new LSLString(s); - } - - public static explicit operator string(Vector3 vec) - { - string s=String.Format("<{0:0.000000},{1:0.000000},{2:0.000000}>", vec.x, vec.y, vec.z); - return s; - } - - public static explicit operator Vector3(string s) - { - return new Vector3(s); - } - - public static bool operator ==(Vector3 lhs, Vector3 rhs) - { - return (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z); - } - - public static bool operator !=(Vector3 lhs, Vector3 rhs) - { - return !(lhs == rhs); - } - - public override int GetHashCode() - { - return (x.GetHashCode() ^ y.GetHashCode() ^ z.GetHashCode()); - } - - public override bool Equals(object o) - { - if (!(o is Vector3)) return false; - - Vector3 vector = (Vector3)o; - - return (x == vector.x && x == vector.x && z == vector.z); - } - - #endregion - - #region Vector & Vector Math - - // Vector-Vector Math - public static Vector3 operator +(Vector3 lhs, Vector3 rhs) - { - return new Vector3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); - } - - public static Vector3 operator -(Vector3 lhs, Vector3 rhs) - { - return new Vector3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); - } - - public static Vector3 operator *(Vector3 lhs, Vector3 rhs) - { - return new Vector3(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z); - } - - public static Vector3 operator %(Vector3 v1, Vector3 v2) - { - //Cross product - Vector3 tv; - tv.x = (v1.y * v2.z) - (v1.z * v2.y); - tv.y = (v1.z * v2.x) - (v1.x * v2.z); - tv.z = (v1.x * v2.y) - (v1.y * v2.x); - return tv; - } - - #endregion - - #region Vector & Float Math - - // Vector-Float and Float-Vector Math - public static Vector3 operator *(Vector3 vec, float val) - { - return new Vector3(vec.x * val, vec.y * val, vec.z * val); - } - - public static Vector3 operator *(float val, Vector3 vec) - { - return new Vector3(vec.x * val, vec.y * val, vec.z * val); - } - - public static Vector3 operator /(Vector3 v, float f) - { - v.x = v.x / f; - v.y = v.y / f; - v.z = v.z / f; - return v; - } - - #endregion - - #region Vector & Double Math - - public static Vector3 operator *(Vector3 vec, double val) - { - return new Vector3(vec.x * val, vec.y * val, vec.z * val); - } - - public static Vector3 operator *(double val, Vector3 vec) - { - return new Vector3(vec.x * val, vec.y * val, vec.z * val); - } - - public static Vector3 operator /(Vector3 v, double f) - { - v.x = v.x / f; - v.y = v.y / f; - v.z = v.z / f; - return v; - } - - #endregion - - #region Vector & Rotation Math - - // Vector-Rotation Math - public static Vector3 operator *(Vector3 v, Quaternion r) - { - Quaternion vq = new Quaternion(v.x, v.y, v.z, 0); - Quaternion nq = new Quaternion(-r.x, -r.y, -r.z, r.s); - - // adapted for operator * computing "b * a" - Quaternion result = nq * (vq * r); - - return new Vector3(result.x, result.y, result.z); - } - - public static Vector3 operator /(Vector3 v, Quaternion r) - { - r.s = -r.s; - return v * r; - } - - #endregion - - #region Static Helper Functions - - public static double Dot(Vector3 v1, Vector3 v2) - { - return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z); - } - - public static Vector3 Cross(Vector3 v1, Vector3 v2) - { - return new Vector3 - ( - v1.y * v2.z - v1.z * v2.y, - v1.z * v2.x - v1.x * v2.z, - v1.x * v2.y - v1.y * v2.x - ); - } - - public static double Mag(Vector3 v) - { - return Math.Sqrt(v.x * v.x + v.y * v.y + v.z * v.z); - } - - public static Vector3 Norm(Vector3 vector) - { - double mag = Mag(vector); - return new Vector3(vector.x / mag, vector.y / mag, vector.z / mag); - } - - #endregion - } - - [Serializable] - public struct Quaternion - { - public double x; - public double y; - public double z; - public double s; - - #region Constructors - - public Quaternion(Quaternion Quat) - { - x = (float)Quat.x; - y = (float)Quat.y; - z = (float)Quat.z; - s = (float)Quat.s; - if (x == 0 && y == 0 && z == 0 && s == 0) - s = 1; - } - - public Quaternion(double X, double Y, double Z, double S) - { - x = X; - y = Y; - z = Z; - s = S; - if (x == 0 && y == 0 && z == 0 && s == 0) - s = 1; - } - - public Quaternion(string str) - { - str = str.Replace('<', ' '); - str = str.Replace('>', ' '); - string[] tmps = str.Split(new Char[] { ',', '<', '>' }); - if (tmps.Length < 4) - { - x=y=z=s=0; - return; - } - bool res; - res = Double.TryParse(tmps[0], out x); - res = res & Double.TryParse(tmps[1], out y); - res = res & Double.TryParse(tmps[2], out z); - res = res & Double.TryParse(tmps[3], out s); - if (x == 0 && y == 0 && z == 0 && s == 0) - s = 1; - } - - #endregion - - #region Overriders - - public override int GetHashCode() - { - return (x.GetHashCode() ^ y.GetHashCode() ^ z.GetHashCode() ^ s.GetHashCode()); - } - - public override bool Equals(object o) - { - if (!(o is Quaternion)) return false; - - Quaternion quaternion = (Quaternion)o; - - return x == quaternion.x && y == quaternion.y && z == quaternion.z && s == quaternion.s; - } - - public override string ToString() - { - string st=String.Format("<{0:0.000000},{1:0.000000},{2:0.000000},{3:0.000000}>", x, y, z, s); - return st; - } - - public static explicit operator string(Quaternion r) - { - string s=String.Format("<{0:0.000000},{1:0.000000},{2:0.000000},{3:0.000000}>", r.x, r.y, r.z, r.s); - return s; - } - - public static explicit operator LSLString(Quaternion r) - { - string s=String.Format("<{0:0.000000},{1:0.000000},{2:0.000000},{3:0.000000}>", r.x, r.y, r.z, r.s); - return new LSLString(s); - } - - public static explicit operator Quaternion(string s) - { - return new Quaternion(s); - } - - public static bool operator ==(Quaternion lhs, Quaternion rhs) - { - // Return true if the fields match: - return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z && lhs.s == rhs.s; - } - - public static bool operator !=(Quaternion lhs, Quaternion rhs) - { - return !(lhs == rhs); - } - - #endregion - - public static Quaternion operator +(Quaternion a, Quaternion b) - { - return new Quaternion(a.x + b.x, a.y + b.y, a.z + b.z, a.s + b.s); - } - - public static Quaternion operator /(Quaternion a, Quaternion b) - { - b.s = -b.s; - return a * b; - } - - public static Quaternion operator -(Quaternion a, Quaternion b) - { - return new Quaternion(a.x - b.x, a.y - b.y, a.z - b.z, a.s - b.s); - } - - // using the equations below, we need to do "b * a" to be compatible with LSL - public static Quaternion operator *(Quaternion b, Quaternion a) - { - Quaternion c; - c.x = a.s * b.x + a.x * b.s + a.y * b.z - a.z * b.y; - c.y = a.s * b.y + a.y * b.s + a.z * b.x - a.x * b.z; - c.z = a.s * b.z + a.z * b.s + a.x * b.y - a.y * b.x; - c.s = a.s * b.s - a.x * b.x - a.y * b.y - a.z * b.z; - return c; - } - } - - [Serializable] - public class list - { - private object[] m_data; - - public list(params object[] args) - { - m_data = new object[args.Length]; - m_data = args; - } - - public int Length - { - get { - if (m_data == null) - m_data=new Object[0]; - return m_data.Length; - } - } - - public object[] Data - { - get { - if (m_data == null) - m_data=new Object[0]; - return m_data; - } - } - - public static list operator +(list a, list b) - { - object[] tmp; - tmp = new object[a.Length + b.Length]; - a.Data.CopyTo(tmp, 0); - b.Data.CopyTo(tmp, a.Length); - return new list(tmp); - } - - private void ExtendAndAdd(object o) - { - Array.Resize(ref m_data, Length + 1); - m_data.SetValue(o, Length - 1); - } - - public static list operator +(list a, string s) - { - a.ExtendAndAdd(s); - return a; - } - - public static list operator +(list a, int i) - { - a.ExtendAndAdd(i); - return a; - } - - public static list operator +(list a, double d) - { - a.ExtendAndAdd(d); - return a; - } - - public void Add(object o) - { - object[] tmp; - tmp = new object[m_data.Length + 1]; - m_data.CopyTo(tmp, 0); - tmp[m_data.Length] = o; - m_data = tmp; - } - - public bool Contains(object o) - { - bool ret = false; - foreach (object i in Data) - { - if (i == o) - { - ret = true; - break; - } - } - return ret; - } - - public list DeleteSublist(int start, int end) - { - // Not an easy one - // If start <= end, remove that part - // if either is negative, count from the end of the array - // if the resulting start > end, remove all BUT that part - - Object[] ret; - - if (start < 0) - start=m_data.Length-start; - - if (start < 0) - start=0; - - if (end < 0) - end=m_data.Length-end; - if (end < 0) - end=0; - - if (start > end) - { - if (end >= m_data.Length) - return new list(new Object[0]); - - if (start >= m_data.Length) - start=m_data.Length-1; - - return GetSublist(end, start); - } - - // start >= 0 && end >= 0 here - if (start >= m_data.Length) - { - ret=new Object[m_data.Length]; - Array.Copy(m_data, 0, ret, 0, m_data.Length); - - return new list(ret); - } - - if (end >= m_data.Length) - end=m_data.Length-1; - - // now, this makes the math easier - int remove=end+1-start; - - ret=new Object[m_data.Length-remove]; - if (ret.Length == 0) - return new list(ret); - - int src; - int dest=0; - - for (src = 0; src < m_data.Length; src++) - { - if (src < start || src > end) - ret[dest++]=m_data[src]; - } - - return new list(ret); - } - - public list GetSublist(int start, int end) - { - - object[] ret; - - // Take care of neg start or end's - // NOTE that either index may still be negative after - // adding the length, so we must take additional - // measures to protect against this. Note also that - // after normalisation the negative indices are no - // longer relative to the end of the list. - - if (start < 0) - { - start = m_data.Length + start; - } - - if (end < 0) - { - end = m_data.Length + end; - } - - // The conventional case is start <= end - // NOTE that the case of an empty list is - // dealt with by the initial test. Start - // less than end is taken to be the most - // common case. - - if (start <= end) - { - - // Start sublist beyond length - // Also deals with start AND end still negative - if (start >= m_data.Length || end < 0) - { - return new list(); - } - - // Sublist extends beyond the end of the supplied list - if (end >= m_data.Length) - { - end = m_data.Length - 1; - } - - // Sublist still starts before the beginning of the list - if (start < 0) - { - start = 0; - } - - ret = new object[end - start + 1]; - - Array.Copy(m_data, start, ret, 0, end - start + 1); - - return new list(ret); - - } - - // Deal with the segmented case: 0->end + start->EOL - - else - { - - list result = null; - - // If end is negative, then prefix list is empty - if (end < 0) - { - result = new list(); - // If start is still negative, then the whole of - // the existing list is returned. This case is - // only admitted if end is also still negative. - if (start < 0) - { - return this; - } - - } - else - { - result = GetSublist(0,end); - } - - // If start is outside of list, then just return - // the prefix, whatever it is. - if (start >= m_data.Length) - { - return result; - } - - return result + GetSublist(start, Data.Length); - - } - } - - public list Sort(int stride, int ascending) - { - if (Data.Length == 0) - return new list(); // Don't even bother - - string[] keys; - - if (stride == 1) // The simple case - { - Object[] ret=new Object[Data.Length]; - - Array.Copy(Data, 0, ret, 0, Data.Length); - - keys=new string[Data.Length]; - - for (int k = 0; k < Data.Length; k++) - keys[k] = Data[k].ToString(); - - Array.Sort(keys, ret); - - if (ascending == 0) - Array.Reverse(ret); - return new list(ret); - } - - int src=0; - - int len=(Data.Length+stride-1)/stride; - - keys=new string[len]; - Object[][] vals=new Object[len][]; - - int i; - - while (src < Data.Length) - { - Object[] o=new Object[stride]; - - for (i = 0; i < stride; i++) - { - if (src < Data.Length) - o[i]=Data[src++]; - else - { - o[i]=new Object(); - src++; - } - } - - int idx=src/stride-1; - keys[idx]=o[0].ToString(); - vals[idx]=o; - } - - Array.Sort(keys, vals); - if (ascending == 0) - { - Array.Reverse(vals); - } - - Object[] sorted=new Object[stride*vals.Length]; - - for (i = 0; i < vals.Length; i++) - for (int j = 0; j < stride; j++) - sorted[i*stride+j] = vals[i][j]; - - return new list(sorted); - } - - #region CSV Methods - - public static list FromCSV(string csv) - { - return new list(csv.Split(',')); - } - - public string ToCSV() - { - string ret = ""; - foreach (object o in this.Data) - { - if (ret == "") - { - ret = o.ToString(); - } - else - { - ret = ret + ", " + o.ToString(); - } - } - return ret; - } - - private string ToSoup() - { - string output; - output = String.Empty; - if (m_data.Length == 0) - { - return String.Empty; - } - foreach (object o in m_data) - { - output = output + o.ToString(); - } - return output; - } - - public static explicit operator String(list l) - { - return l.ToSoup(); - } - - public static explicit operator LSLString(list l) - { - return new LSLString(l.ToSoup()); - } - - public override string ToString() - { - return ToSoup(); - } - - #endregion - - #region Statistic Methods - - public double Min() - { - double minimum = double.PositiveInfinity; - double entry; - for (int i = 0; i < Data.Length; i++) - { - if (double.TryParse(Data[i].ToString(), out entry)) - { - if (entry < minimum) minimum = entry; - } - } - return minimum; - } - - public double Max() - { - double maximum = double.NegativeInfinity; - double entry; - for (int i = 0; i < Data.Length; i++) - { - if (double.TryParse(Data[i].ToString(), out entry)) - { - if (entry > maximum) maximum = entry; - } - } - return maximum; - } - - public double Range() - { - return (this.Max() / this.Min()); - } - - public int NumericLength() - { - int count = 0; - double entry; - for (int i = 0; i < Data.Length; i++) - { - if (double.TryParse(Data[i].ToString(), out entry)) - { - count++; - } - } - return count; - } - - public static list ToDoubleList(list src) - { - list ret = new list(); - double entry; - for (int i = 0; i < src.Data.Length - 1; i++) - { - if (double.TryParse(src.Data[i].ToString(), out entry)) - { - ret.Add(entry); - } - } - return ret; - } - - public double Sum() - { - double sum = 0; - double entry; - for (int i = 0; i < Data.Length; i++) - { - if (double.TryParse(Data[i].ToString(), out entry)) - { - sum = sum + entry; - } - } - return sum; - } - - public double SumSqrs() - { - double sum = 0; - double entry; - for (int i = 0; i < Data.Length; i++) - { - if (double.TryParse(Data[i].ToString(), out entry)) - { - sum = sum + Math.Pow(entry, 2); - } - } - return sum; - } - - public double Mean() - { - return (this.Sum() / this.NumericLength()); - } - - public void NumericSort() - { - IComparer Numeric = new NumericComparer(); - Array.Sort(Data, Numeric); - } - - public void AlphaSort() - { - IComparer Alpha = new AlphaCompare(); - Array.Sort(Data, Alpha); - } - - public double Median() - { - return Qi(0.5); - } - - public double GeometricMean() - { - double ret = 1.0; - list nums = ToDoubleList(this); - for (int i = 0; i < nums.Data.Length; i++) - { - ret *= (double)nums.Data[i]; - } - return Math.Exp(Math.Log(ret) / (double)nums.Data.Length); - } - - public double HarmonicMean() - { - double ret = 0.0; - list nums = ToDoubleList(this); - for (int i = 0; i < nums.Data.Length; i++) - { - ret += 1.0 / (double)nums.Data[i]; - } - return ((double)nums.Data.Length / ret); - } - - public double Variance() - { - double s = 0; - list num = ToDoubleList(this); - for (int i = 0; i < num.Data.Length; i++) - { - s += Math.Pow((double)num.Data[i], 2); - } - return (s - num.Data.Length * Math.Pow(num.Mean(), 2)) / (num.Data.Length - 1); - } - - public double StdDev() - { - return Math.Sqrt(this.Variance()); - } - - public double Qi(double i) - { - list j = this; - j.NumericSort(); - - if (Math.Ceiling(this.Length * i) == this.Length * i) - { - return (double)((double)j.Data[(int)(this.Length * i - 1)] + (double)j.Data[(int)(this.Length * i)]) / 2; - } - else - { - return (double)j.Data[((int)(Math.Ceiling(this.Length * i))) - 1]; - } - } - - #endregion - - public string ToPrettyString() - { - string output; - if (m_data.Length == 0) - { - return "[]"; - } - output = "["; - foreach (object o in m_data) - { - if (o is String) - { - output = output + "\"" + o + "\", "; - } - else - { - output = output + o.ToString() + ", "; - } - } - output = output.Substring(0, output.Length - 2); - output = output + "]"; - return output; - } - - public class AlphaCompare : IComparer - { - int IComparer.Compare(object x, object y) - { - return string.Compare(x.ToString(), y.ToString()); - } - } - - public class NumericComparer : IComparer - { - int IComparer.Compare(object x, object y) - { - double a; - double b; - if (!double.TryParse(x.ToString(), out a)) - { - a = 0.0; - } - if (!double.TryParse(y.ToString(), out b)) - { - b = 0.0; - } - if (a < b) - { - return -1; - } - else if (a == b) - { - return 0; - } - else - { - return 1; - } - } - } - - } - - // - // BELOW IS WORK IN PROGRESS... IT WILL CHANGE, SO DON'T USE YET! :) - // - - public struct StringTest - { - // Our own little string - internal string actualString; - public static implicit operator bool(StringTest mString) - { - if (mString.actualString.Length == 0) - return true; - return false; - } - public override string ToString() - { - return actualString; - } - - } - - [Serializable] - public struct key - { - public string value; - - #region Constructors - public key(string s) - { - value = s; - } - - #endregion - - #region Methods - - static public bool Parse2Key(string s) - { - Regex isuuid = new Regex(@"^[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}$", RegexOptions.Compiled); - if (isuuid.IsMatch(s)) - { - return true; - } - else - { - return false; - } - } - - #endregion - - #region Operators - - static public implicit operator Boolean(key k) - { - if (k.value.Length == 0) - { - return false; - } - - if (k.value == "00000000-0000-0000-0000-000000000000") - { - return false; - } - Regex isuuid = new Regex(@"^[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}$", RegexOptions.Compiled); - if (isuuid.IsMatch(k.value)) - { - return true; - } - else - { - return false; - } - } - - static public implicit operator key(string s) - { - return new key(s); - } - - static public implicit operator String(key k) - { - return k.value; - } - - public static bool operator ==(key k1, key k2) - { - return k1.value == k2.value; - } - public static bool operator !=(key k1, key k2) - { - return k1.value != k2.value; - } - - #endregion - - #region Overriders - - public override bool Equals(object o) - { - return o.ToString() == value; - } - - public override int GetHashCode() - { - return value.GetHashCode(); - } - - #endregion - } - - [Serializable] - public struct LSLString - { - public string m_string; - #region Constructors - public LSLString(string s) - { - m_string = s; - } - - public LSLString(int i) - { - m_string=i.ToString(); - } - - public LSLString(double d) - { - string s=String.Format("{0:0.000000}", d); - m_string=s; - } - - public LSLString(LSLFloat f) - { - string s=String.Format("{0:0.000000}", f.value); - m_string=s; - } - - #endregion - - #region Operators - static public implicit operator Boolean(LSLString s) - { - if (s.m_string.Length == 0) - { - return false; - } - else - { - return true; - } - } - - - - static public implicit operator String(LSLString s) - { - return s.m_string; - } - - static public implicit operator LSLString(string s) - { - return new LSLString(s); - } - - public static string ToString(LSLString s) - { - return s.m_string; - } - - public override string ToString() - { - return m_string; - } - - public static bool operator ==(LSLString s1, string s2) - { - return s1.m_string == s2; - } - - public static bool operator !=(LSLString s1, string s2) - { - return s1.m_string != s2; - } - - public static explicit operator double(LSLString s) - { - return Convert.ToDouble(s.m_string); - } - - public static explicit operator LSLInteger(LSLString s) - { - return new LSLInteger(Convert.ToInt32(s.m_string)); - } - - public static explicit operator LSLString(int i) - { - return new LSLString(i); - } - - public static explicit operator LSLString(double d) - { - return new LSLString(d); - } - - public static explicit operator LSLString(LSLFloat f) - { - return new LSLString(f); - } - - public static implicit operator Vector3(LSLString s) - { - return new Vector3(s.m_string); - } - - #endregion - - #region Overriders - public override bool Equals(object o) - { - return m_string == o.ToString(); - } - - public override int GetHashCode() - { - return m_string.GetHashCode(); - } - - #endregion - - #region " Standard string functions " - //Clone,CompareTo,Contains - //CopyTo,EndsWith,Equals,GetEnumerator,GetHashCode,GetType,GetTypeCode - //IndexOf,IndexOfAny,Insert,IsNormalized,LastIndexOf,LastIndexOfAny - //Length,Normalize,PadLeft,PadRight,Remove,Replace,Split,StartsWith,Substring,ToCharArray,ToLowerInvariant - //ToString,ToUpper,ToUpperInvariant,Trim,TrimEnd,TrimStart - public bool Contains(string value) { return m_string.Contains(value); } - public int IndexOf(string value) { return m_string.IndexOf(value); } - public int Length { get { return m_string.Length; } } - - - #endregion - } - - [Serializable] - public struct LSLInteger - { - public int value; - - #region Constructors - public LSLInteger(int i) - { - value = i; - } - - public LSLInteger(double d) - { - value = (int)d; - } - - public LSLInteger(Object o) - { - if (!(o is Int32)) - value = 0; - else - value = (int)o; - } - - public LSLInteger(string s) - { - value = int.Parse(s); - } - - #endregion - - #region Operators - - static public implicit operator int(LSLInteger i) - { - return i.value; - } - - static public implicit operator uint(LSLInteger i) - { - return (uint)i.value; - } - - static public explicit operator LSLString(LSLInteger i) - { - return new LSLString(i.ToString()); - } - - static public explicit operator string(LSLInteger i) - { - return i.ToString(); - } - - static public implicit operator Boolean(LSLInteger i) - { - if (i.value == 0) - { - return false; - } - else - { - return true; - } - } - - static public implicit operator LSLInteger(int i) - { - return new LSLInteger(i); - } - - static public explicit operator LSLInteger(string s) - { - return new LSLInteger(int.Parse(s)); - } - - static public implicit operator LSLInteger(double d) - { - return new LSLInteger(d); - } - - static public bool operator ==(LSLInteger i1, LSLInteger i2) - { - bool ret = i1.value == i2.value; - return ret; - } - - static public bool operator !=(LSLInteger i1, LSLInteger i2) - { - bool ret = i1.value != i2.value; - return ret; - } - - static public LSLInteger operator &(LSLInteger i1, LSLInteger i2) - { - int ret = i1.value & i2.value; - return ret; - } - - public static LSLInteger operator ++(LSLInteger i) - { - i.value++; - return i; - } - - - public static LSLInteger operator --(LSLInteger i) - { - i.value--; - return i; - } - - static public implicit operator System.Double(LSLInteger i) - { - return (double)i.value; - } - - static public implicit operator LSLFloat(LSLInteger i) - { - return new LSLFloat((double)i.value); - } - - public static bool operator true(LSLInteger i) - { - return i.value != 0; - } - - public static bool operator false(LSLInteger i) - { - return i.value == 0; - } - - #endregion - - #region Overriders - - public override string ToString() - { - return this.value.ToString(); - } - - public override bool Equals(object o) - { - if (o is Int32) - { - return value == (Int32)o; - } - if (o is LSLInteger) - { - return value == ((LSLInteger)o).value; - } - return false; - } - - public override int GetHashCode() - { - return value.GetHashCode(); - } - - #endregion - } - - [Serializable] - public struct LSLFloat - { - public double value; - - #region Constructors - - public LSLFloat(int i) - { - value = (double)i; - } - - public LSLFloat(double d) - { - value = d; - } - - public LSLFloat(string s) - { - value = double.Parse(s); - } - - public LSLFloat(Object o) - { - if (!((o is double) || (o is float))) - { - value = 0.0; - return; - } - - value = (double)o; - } - - #endregion - - #region Operators - - static public implicit operator int(LSLFloat f) - { - return (int)f.value; - } - - static public implicit operator uint(LSLFloat f) - { - return (uint) Math.Abs(f.value); - } - - static public implicit operator Boolean(LSLFloat f) - { - if (f.value == 0.0) - { - return false; - } - else - { - return true; - } - } - - static public implicit operator LSLFloat(int i) - { - return new LSLFloat(i); - } - - static public implicit operator LSLFloat(string s) - { - return new LSLFloat(double.Parse(s)); - } - - static public implicit operator LSLFloat(double d) - { - return new LSLFloat(d); - } - - static public bool operator ==(LSLFloat f1, LSLFloat f2) - { - return f1.value == f2.value; - } - - static public bool operator !=(LSLFloat f1, LSLFloat f2) - { - return f1.value != f2.value; - } - - static public LSLFloat operator ++(LSLFloat f) - { - f.value++; - return f; - } - - static public LSLFloat operator --(LSLFloat f) - { - f.value--; - return f; - } - - static public implicit operator System.Double(LSLFloat f) - { - return f.value; - } - - static public explicit operator LSLString(LSLFloat f) - { - string v = String.Format("{0:0.000000}", f.value); - return new LSLString(v); - } - - #endregion - - #region Overriders - - public override string ToString() - { - return String.Format("{0:0.000000}", this.value); - } - - #endregion - } - } -} diff --git a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs index 0b0ff3d..709e3ee 100644 --- a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs +++ b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs @@ -14,11 +14,15 @@ using OpenSim.Framework; using OpenSim.Region.Environment; using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Interfaces; -using OpenSim.Region.ScriptEngine.XEngine.Script; +using OpenSim.Region.ScriptEngine.Shared; +using OpenSim.Region.ScriptEngine.Shared.Api; +using OpenSim.Region.ScriptEngine.Shared.ScriptBase; +using OpenSim.Region.ScriptEngine.Shared.CodeTools; +using OpenSim.Region.ScriptEngine.Interfaces; namespace OpenSim.Region.ScriptEngine.XEngine { - public class XEngine : IRegionModule + public class XEngine : IRegionModule, IScriptEngine { private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); @@ -30,10 +34,10 @@ namespace OpenSim.Region.ScriptEngine.XEngine private EventManager m_EventManager; private int m_EventLimit; private bool m_KillTimedOutScripts; + public AsyncCommandManager m_AsyncCommands; private static List m_ScriptEngines = new List(); - public AsyncCommandManager m_ASYNCLSLCommandManager; // Maps the local id to the script inventory items in it @@ -87,11 +91,16 @@ namespace OpenSim.Region.ScriptEngine.XEngine string Script; } - public IConfig ScriptConfigSource + public IConfig Config { get { return m_ScriptConfig; } } + public Object AsyncCommands + { + get { return (Object)m_AsyncCommands; } + } + // // IRegionModule functions // @@ -155,7 +164,6 @@ namespace OpenSim.Region.ScriptEngine.XEngine } m_EventManager = new EventManager(this); - m_ASYNCLSLCommandManager = new AsyncCommandManager(this); StartEngine(minThreads, maxThreads, idleTimeout, prio, maxScriptQueue, stackSize); @@ -166,6 +174,8 @@ namespace OpenSim.Region.ScriptEngine.XEngine m_Scene.EventManager.OnRemoveScript += OnRemoveScript; m_Scene.EventManager.OnScriptReset += OnScriptReset; + m_AsyncCommands = new AsyncCommandManager(this); + if (sleepTime > 0) { m_ThreadPool.QueueWorkItem(new WorkItemCallback( @@ -418,7 +428,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine if (!m_Scripts.ContainsKey(itemID)) return; - m_ASYNCLSLCommandManager.RemoveScript(localID, itemID); + m_AsyncCommands.RemoveScript(localID, itemID); XScriptInstance instance=m_Scripts[itemID]; m_Scripts.Remove(itemID); @@ -552,7 +562,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine // // Post event to an entire prim // - public bool PostObjectEvent(uint localID, XEventParams p) + public bool PostObjectEvent(uint localID, EventParams p) { bool result = false; @@ -577,7 +587,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine // // Post an event to a single script // - public bool PostScriptEvent(LLUUID itemID, XEventParams p) + public bool PostScriptEvent(LLUUID itemID, EventParams p) { if (m_Scripts.ContainsKey(itemID)) { @@ -654,7 +664,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine instance.ResetScript(); } - public XDetectParams GetDetectParams(LLUUID itemID, int idx) + public DetectParams GetDetectParams(LLUUID itemID, int idx) { XScriptInstance instance = GetInstance(itemID); if (instance != null) @@ -669,115 +679,21 @@ namespace OpenSim.Region.ScriptEngine.XEngine return instance.GetDetectID(idx); return LLUUID.Zero; } - } - - public class XDetectParams - { - public XDetectParams() - { - Key = LLUUID.Zero; - OffsetPos = new LSL_Types.Vector3(); - LinkNum = 0; - Group = LLUUID.Zero; - Name = String.Empty; - Owner = LLUUID.Zero; - Position = new LSL_Types.Vector3(); - Rotation = new LSL_Types.Quaternion(); - Type = 0; - Velocity = new LSL_Types.Vector3(); - } - - public LLUUID Key; - public LSL_Types.Vector3 OffsetPos; - public int LinkNum; - public LLUUID Group; - public string Name; - public LLUUID Owner; - public LSL_Types.Vector3 Position; - public LSL_Types.Quaternion Rotation; - public int Type; - public LSL_Types.Vector3 Velocity; - - public void Populate(Scene scene) - { - SceneObjectPart part = scene.GetSceneObjectPart(Key); - if (part == null) // Avatar, maybe? - { - ScenePresence presence = scene.GetScenePresence(Key); - if (presence == null) - return; - - Name = presence.Firstname + " " + presence.Lastname; - Owner = Key; - Position = new LSL_Types.Vector3( - presence.AbsolutePosition.X, - presence.AbsolutePosition.X, - presence.AbsolutePosition.Z); - Rotation = new LSL_Types.Quaternion( - presence.Rotation.x, - presence.Rotation.y, - presence.Rotation.z, - presence.Rotation.w); - Velocity = new LSL_Types.Vector3( - presence.Velocity.X, - presence.Velocity.X, - presence.Velocity.Z); - - Type = 0x01; // Avatar - if (presence.Velocity != LLVector3.Zero) - Type |= 0x02; // Active - - Group = presence.ControllingClient.ActiveGroupId; + public void SetState(LLUUID itemID, string newState) + { + XScriptInstance instance = GetInstance(itemID); + if (instance == null) return; - } - - part=part.ParentGroup.RootPart; // We detect objects only - - LinkNum = 0; // Not relevant - - Group = part.GroupID; - Name = part.Name; - Owner = part.OwnerID; - if (part.Velocity == LLVector3.Zero) - Type = 0x04; // Passive - else - Type = 0x02; // Passive - - foreach (SceneObjectPart p in part.ParentGroup.Children.Values) - { - if (part.ContainsScripts()) - { - Type |= 0x08; // Scripted - break; - } - } - - Position = new LSL_Types.Vector3(part.AbsolutePosition.X, - part.AbsolutePosition.Y, - part.AbsolutePosition.Z); - - LLQuaternion wr = part.GetWorldRotation(); - Rotation = new LSL_Types.Quaternion(wr.X, wr.Y, wr.Z, wr.W); - - Velocity = new LSL_Types.Vector3(part.Velocity.X, - part.Velocity.Y, - part.Velocity.Z); + instance.SetState(newState); } - } - - public class XEventParams - { - public XEventParams(string eventName, Object[] eventParams, XDetectParams[] detectParams) + public string GetState(LLUUID itemID) { - EventName=eventName; - Params=eventParams; - DetectParams=detectParams; + XScriptInstance instance = GetInstance(itemID); + if (instance == null) + return "default"; + return instance.State; } - - public string EventName; - public Object[] Params; - public XDetectParams[] DetectParams; } public class XScriptInstance @@ -791,17 +707,16 @@ namespace OpenSim.Region.ScriptEngine.XEngine private LLUUID m_ObjectID; private LLUUID m_AssetID; private IScript m_Script; - private LSL_ScriptCommands m_LSLCommands; - private OSSL_ScriptCommands m_OSSLCommands; private Executor m_Executor; private LLUUID m_AppDomain; - private XDetectParams[] m_DetectParams; + private DetectParams[] m_DetectParams; private bool m_TimerQueued; private DateTime m_EventStart; private bool m_InEvent; private string m_PrimName; private string m_ScriptName; private string m_Assembly; + private Dictionary m_Apis = new Dictionary(); public enum StateSource { @@ -893,6 +808,8 @@ namespace OpenSim.Region.ScriptEngine.XEngine m_ScriptName = scriptName; m_Assembly = assembly; + ApiManager am = new ApiManager(); + SceneObjectPart part=engine.World.GetSceneObjectPart(localID); if (part == null) { @@ -900,10 +817,11 @@ namespace OpenSim.Region.ScriptEngine.XEngine return; } - m_LSLCommands = new LSL_ScriptCommands(engine, this, part, localID, - itemID); - m_OSSLCommands = new OSSL_ScriptCommands(engine, this, part, - localID, itemID); + foreach (string api in am.GetApis()) + { + m_Apis[api] = am.CreateApi(api); + m_Apis[api].Initialize(engine, part, localID, itemID); + } try { @@ -918,14 +836,17 @@ namespace OpenSim.Region.ScriptEngine.XEngine try { - m_Script.Start(m_LSLCommands, m_OSSLCommands); + foreach (KeyValuePair kv in m_Apis) + { + m_Script.InitApi(kv.Key, kv.Value); + } m_Executor = new Executor(m_Script); // m_Engine.Log.Debug("[XEngine] Script instance created"); part.SetScriptEvents(m_ItemID, - (int)m_Executor.GetStateEventFlags()); + (int)m_Executor.GetStateEventFlags(State)); } catch (Exception e) { @@ -958,7 +879,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine ScriptSerializer.Deserialize(xml, this); - m_Engine.m_ASYNCLSLCommandManager.CreateFromData( + m_Engine.m_AsyncCommands.CreateFromData( m_LocalID, m_ItemID, m_ObjectID, PluginData); @@ -976,32 +897,32 @@ namespace OpenSim.Region.ScriptEngine.XEngine if (stateSource == StateSource.NewRez) { // m_Engine.Log.Debug("[XEngine] Posted changed(CHANGED_REGION_RESTART) to script"); - PostEvent(new XEventParams("changed", - new Object[] {new LSL_Types.LSLInteger(256)}, new XDetectParams[0])); + PostEvent(new EventParams("changed", + new Object[] {new LSL_Types.LSLInteger(256)}, new DetectParams[0])); } } } else { m_Engine.Log.Error("[XEngine] Unable to load script state: Memory limit exceeded"); - PostEvent(new XEventParams("state_entry", - new Object[0], new XDetectParams[0])); + PostEvent(new EventParams("state_entry", + new Object[0], new DetectParams[0])); Start(); } } catch (Exception e) { m_Engine.Log.ErrorFormat("[XEngine] Unable to load script state from xml: {0}\n"+e.ToString(), xml); - PostEvent(new XEventParams("state_entry", - new Object[0], new XDetectParams[0])); + PostEvent(new EventParams("state_entry", + new Object[0], new DetectParams[0])); Start(); } } else { m_Engine.Log.ErrorFormat("[XEngine] Unable to load script state, file not found"); - PostEvent(new XEventParams("state_entry", - new Object[0], new XDetectParams[0])); + PostEvent(new EventParams("state_entry", + new Object[0], new DetectParams[0])); Start(); } } @@ -1100,15 +1021,15 @@ namespace OpenSim.Region.ScriptEngine.XEngine public void SetState(string state) { - PostEvent(new XEventParams("state_exit", new Object[0], - new XDetectParams[0])); - PostEvent(new XEventParams("state", new Object[] { state }, - new XDetectParams[0])); - PostEvent(new XEventParams("state_entry", new Object[0], - new XDetectParams[0])); + PostEvent(new EventParams("state_exit", new Object[0], + new DetectParams[0])); + PostEvent(new EventParams("state", new Object[] { state }, + new DetectParams[0])); + PostEvent(new EventParams("state_entry", new Object[0], + new DetectParams[0])); } - public void PostEvent(XEventParams data) + public void PostEvent(EventParams data) { // m_Engine.Log.DebugFormat("[XEngine] Posted event {2} in state {3} to {0}.{1}", // m_PrimName, m_ScriptName, data.EventName, m_State); @@ -1137,11 +1058,11 @@ namespace OpenSim.Region.ScriptEngine.XEngine public object EventProcessor() { - XEventParams data = null; + EventParams data = null; lock (m_EventQueue) { - data = (XEventParams) m_EventQueue.Dequeue(); + data = (EventParams) m_EventQueue.Dequeue(); if (data == null) // Shouldn't happen { m_CurrentResult = null; @@ -1158,7 +1079,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine // m_Engine.Log.DebugFormat("[XEngine] Script {0}.{1} state set to {2}", // m_PrimName, m_ScriptName, data.Params[0].ToString()); m_State=data.Params[0].ToString(); - m_Engine.m_ASYNCLSLCommandManager.RemoveScript( + m_Engine.m_AsyncCommands.RemoveScript( m_LocalID, m_ItemID); SceneObjectPart part = m_Engine.World.GetSceneObjectPart( @@ -1166,7 +1087,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine if (part != null) { part.SetScriptEvents(m_ItemID, - (int)m_Executor.GetStateEventFlags()); + (int)m_Executor.GetStateEventFlags(State)); } } else @@ -1181,7 +1102,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine { m_EventStart = DateTime.Now; m_InEvent = true; - m_Executor.ExecuteEvent(data.EventName, data.Params); + m_Executor.ExecuteEvent(State, data.EventName, data.Params); m_InEvent = false; } catch (Exception e) @@ -1259,14 +1180,14 @@ namespace OpenSim.Region.ScriptEngine.XEngine bool running = Running; Stop(0); - m_Engine.m_ASYNCLSLCommandManager.RemoveScript(m_LocalID, m_ItemID); + m_Engine.m_AsyncCommands.RemoveScript(m_LocalID, m_ItemID); m_EventQueue.Clear(); m_Script.ResetVars(); m_State = "default"; if (running) Start(); - PostEvent(new XEventParams("state_entry", - new Object[0], new XDetectParams[0])); + PostEvent(new EventParams("state_entry", + new Object[0], new DetectParams[0])); } public Dictionary GetVars() @@ -1279,7 +1200,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine m_Script.SetVars(vars); } - public XDetectParams GetDetectParams(int idx) + public DetectParams GetDetectParams(int idx) { if (idx < 0 || idx >= m_DetectParams.Length) return null; @@ -1298,7 +1219,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine public void SaveState(string assembly) { PluginData = - m_Engine.m_ASYNCLSLCommandManager.GetSerializationData( + m_Engine.m_AsyncCommands.GetSerializationData( m_ItemID); string xml = ScriptSerializer.Serialize(this); @@ -1368,7 +1289,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine while (count > 0) { - XEventParams ep = (XEventParams)instance.EventQueue.Dequeue(); + EventParams ep = (EventParams)instance.EventQueue.Dequeue(); instance.EventQueue.Enqueue(ep); count--; @@ -1387,7 +1308,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine XmlElement detect = xmldoc.CreateElement("", "Detected", ""); - foreach (XDetectParams det in ep.DetectParams) + foreach (DetectParams det in ep.DetectParams) { XmlElement objectElem = xmldoc.CreateElement("", "Object", ""); @@ -1449,9 +1370,8 @@ namespace OpenSim.Region.ScriptEngine.XEngine rootElement.AppendChild(queue); XmlNode plugins = xmldoc.CreateElement("", "Plugins", ""); - if (instance.PluginData.Length > 0) - DumpList(xmldoc, plugins, - new LSL_Types.list(instance.PluginData)); + DumpList(xmldoc, plugins, + new LSL_Types.list(instance.PluginData)); rootElement.AppendChild(plugins); @@ -1510,8 +1430,8 @@ namespace OpenSim.Region.ScriptEngine.XEngine foreach (XmlNode item in itemL) { List parms = new List(); - List detected = - new List(); + List detected = + new List(); string eventName = item.Attributes.GetNamedItem("event").Value; @@ -1595,7 +1515,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine LLUUID.TryParse(det.InnerText, out uuid); - XDetectParams d = new XDetectParams(); + DetectParams d = new DetectParams(); d.Key = uuid; d.OffsetPos = v; d.LinkNum = d_linkNum; @@ -1612,7 +1532,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine break; } } - XEventParams ep = new XEventParams( + EventParams ep = new EventParams( eventName, parms.ToArray(), detected.ToArray()); instance.EventQueue.Enqueue(ep); -- cgit v1.1