From 2ab7adc2aa9001ab0f83b2f8a11639368c10e226 Mon Sep 17 00:00:00 2001 From: lofcz Date: Sat, 9 Apr 2022 13:28:17 +0200 Subject: [PATCH 001/164] Implement basic parser recovery --- src/MoonSharp.Interpreter/Script.cs | 30 +++++++ src/MoonSharp.Interpreter/ScriptOptions.cs | 12 +++ .../Tree/Statements/CompositeStatement.cs | 84 +++++++++++++++---- .../SyntaxCLike/Errors/1-common-invalid.lua | 4 + .../SyntaxCLike/Errors/1-common-invalid.txt | 0 .../SyntaxCLike/Errors/2-resync-invalid.lua | 6 ++ .../SyntaxCLike/Errors/2-resync-invalid.txt | 0 .../EndToEnd/CLikeTestRunner.cs | 24 +++++- 8 files changed, 143 insertions(+), 17 deletions(-) create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.lua create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.txt create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.lua create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.txt diff --git a/src/MoonSharp.Interpreter/Script.cs b/src/MoonSharp.Interpreter/Script.cs index 3d41e2f8..000b803e 100755 --- a/src/MoonSharp.Interpreter/Script.cs +++ b/src/MoonSharp.Interpreter/Script.cs @@ -12,6 +12,7 @@ using MoonSharp.Interpreter.Interop; using MoonSharp.Interpreter.IO; using MoonSharp.Interpreter.Platforms; +using MoonSharp.Interpreter.Tree; using MoonSharp.Interpreter.Tree.Expressions; using MoonSharp.Interpreter.Tree.Fast_Interface; @@ -23,6 +24,32 @@ namespace MoonSharp.Interpreter /// public class Script : IScriptPrivateResource { + public enum ScriptParserMessageType + { + Error, + Warning, + Info + } + + public class ScriptParserMessage + { + public string Msg { get; set; } + private Token Token { get; set; } + public ScriptParserMessageType Type { get; set; } + + internal ScriptParserMessage(Token token) + { + Token = token; + Msg = $"unexpected symbol near '{token}'"; + } + + internal ScriptParserMessage(Token token, string msg) + { + Token = token; + Msg = msg; + } + } + /// /// The version of the MoonSharp engine /// @@ -39,6 +66,7 @@ public class Script : IScriptPrivateResource Table m_GlobalTable; IDebugger m_Debugger; Table[] m_TypeMetatables = new Table[(int)LuaTypeExtensions.MaxMetaTypes]; + internal List i_ParserMessages { get; set; } = new List(); /// /// Initializes the class. @@ -838,5 +866,7 @@ Script IScriptPrivateResource.OwnerScript { get { return this; } } + + public List ParserMessages => i_ParserMessages; } } diff --git a/src/MoonSharp.Interpreter/ScriptOptions.cs b/src/MoonSharp.Interpreter/ScriptOptions.cs index 901d3c4b..238f1a06 100644 --- a/src/MoonSharp.Interpreter/ScriptOptions.cs +++ b/src/MoonSharp.Interpreter/ScriptOptions.cs @@ -29,6 +29,12 @@ internal ScriptOptions(ScriptOptions defaults) this.CheckThreadAccess = defaults.CheckThreadAccess; } + + public enum ParserErrorModes + { + Throw, + Report + } /// /// Gets or sets the current script-loader. @@ -127,5 +133,11 @@ internal ScriptOptions(ScriptOptions defaults) /// These directions will store the RHS as a string annotation on the chunk. /// public HashSet Directives { get; set; } = new HashSet(); + + /// + /// Specifies how parser reacts to errors while parsing. + /// Options are: Throw (paring is aborted after first error), Report (errors are stashed and available in Script.ParserMessages) + /// + public ParserErrorModes ParserErrorMode { get; set; } = ParserErrorModes.Throw; } } diff --git a/src/MoonSharp.Interpreter/Tree/Statements/CompositeStatement.cs b/src/MoonSharp.Interpreter/Tree/Statements/CompositeStatement.cs index e31760b6..e3673e48 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/CompositeStatement.cs +++ b/src/MoonSharp.Interpreter/Tree/Statements/CompositeStatement.cs @@ -1,4 +1,5 @@ -using System.Collections.Generic; +using System; +using System.Collections.Generic; using MoonSharp.Interpreter.Execution; @@ -14,30 +15,85 @@ class CompositeStatement : Statement { List m_Statements = new List(); - public Token EndToken; - public CompositeStatement(ScriptLoadingContext lcontext, BlockEndType endType) : base(lcontext) { while (true) { - ParseAnnotations(lcontext); - Token t = lcontext.Lexer.Current; - EndToken = lcontext.Lexer.Current; - if (t.IsEndOfBlock()) break; - if (endType == BlockEndType.CloseCurly && t.Type == TokenType.Brk_Close_Curly) break; - bool forceLast; - - Statement s = Statement.CreateStatement(lcontext, out forceLast); - m_Statements.Add(s); - EndToken = lcontext.Lexer.Current; - if (forceLast) break; + try + { + ParseAnnotations(lcontext); + Token t = lcontext.Lexer.Current; + if (t.IsEndOfBlock()) break; + if (endType == BlockEndType.CloseCurly && t.Type == TokenType.Brk_Close_Curly) break; + + Statement s = CreateStatement(lcontext, out bool forceLast); + m_Statements.Add(s); + if (forceLast) break; + } + catch (InterpreterException e) + { + if (lcontext.Script.Options.ParserErrorMode == ScriptOptions.ParserErrorModes.Report) + { + Token token = null; + if (e is SyntaxErrorException se) + { + token = se.Token; + } + + lcontext.Script.i_ParserMessages.Add(new Script.ScriptParserMessage(token, e.Message)); + Synchronize(lcontext); + + if (lcontext.Lexer.PeekNext().Type == TokenType.Eof) + { + lcontext.Lexer.Next(); + break; + } + } + else + { + throw; + } + } } // eat away all superfluos ';'s while (lcontext.Lexer.Current.Type == TokenType.SemiColon) lcontext.Lexer.Next(); } + + private void Synchronize(ScriptLoadingContext lcontext) + { + while (lcontext.Lexer.PeekNext().Type != TokenType.Eof) + { + lcontext.Lexer.Next(); + Token tkn = lcontext.Lexer.Current; + + switch (tkn.Type) + { + case TokenType.ChunkAnnotation: + case TokenType.Local: + case TokenType.Until: + case TokenType.Break: + case TokenType.Continue: + case TokenType.While: + case TokenType.For: + case TokenType.ElseIf: + case TokenType.Else: + case TokenType.Function: + case TokenType.Goto: + case TokenType.Directive: + case TokenType.Do: + case TokenType.If: + { + goto endSynchronize; + } + } + } + + endSynchronize: ; + } + public override void ResolveScope(ScriptLoadingContext lcontext) { diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.lua b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.lua new file mode 100644 index 00000000..46dd1292 --- /dev/null +++ b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.lua @@ -0,0 +1,4 @@ +if ( + +x = 0 +x1 = [] \ No newline at end of file diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.txt b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.txt new file mode 100644 index 00000000..e69de29b diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.lua b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.lua new file mode 100644 index 00000000..76f75a93 --- /dev/null +++ b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.lua @@ -0,0 +1,6 @@ +if ( + +x = 0 +x1 = [] + +local x1 = = = \ No newline at end of file diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.txt b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.txt new file mode 100644 index 00000000..e69de29b diff --git a/src/MoonSharp.Tests/EndToEnd/CLikeTestRunner.cs b/src/MoonSharp.Tests/EndToEnd/CLikeTestRunner.cs index 988ca721..4173af85 100644 --- a/src/MoonSharp.Tests/EndToEnd/CLikeTestRunner.cs +++ b/src/MoonSharp.Tests/EndToEnd/CLikeTestRunner.cs @@ -16,9 +16,20 @@ static string[] GetTestCases() return files; } + + [Test, TestCaseSource(nameof(GetTestCases))] + public async Task RunThrowErros(string path) + { + await RunCore(path); + } [Test, TestCaseSource(nameof(GetTestCases))] - public async Task Run(string path) + public async Task RunReportErrors(string path) + { + await RunCore(path, true); + } + + public async Task RunCore(string path, bool reportErrors = false) { string outputPath = path.Replace(".lua", ".txt"); @@ -36,14 +47,21 @@ public async Task Run(string path) script.Options.DebugPrint = s => stdOut.AppendLine(s); script.Options.IndexTablesFrom = 0; + if (path.Contains("flaky")) + { + Assert.Inconclusive($"Test {path} marked as flaky"); + return; + } + if (path.Contains("SyntaxCLike")) { script.Options.Syntax = ScriptSyntax.CLike; } - if (path.Contains("flaky")) + if (reportErrors) { - Assert.Inconclusive($"Test {path} marked as flaky"); + script.Options.ParserErrorMode = ScriptOptions.ParserErrorModes.Report; + await script.DoStringAsync(code); return; } From e6f988125cb91ac2a2f8461c95cd1c7eb7c307b8 Mon Sep 17 00:00:00 2001 From: lofcz Date: Sat, 9 Apr 2022 18:57:03 +0200 Subject: [PATCH 002/164] Relax brks around annotations --- .../IAnnotationPolicy.cs | 42 ++++++++++++++++- src/MoonSharp.Interpreter/ScriptOptions.cs | 1 + src/MoonSharp.Interpreter/Tree/Statement.cs | 46 +++++++++++++++++-- .../SyntaxCLike/Annotations/1-annotation.lua | 4 ++ .../SyntaxCLike/Annotations/1-annotation.txt | 0 .../SyntaxCLike/Annotations/2-annotation.lua | 4 ++ .../SyntaxCLike/Annotations/2-annotation.txt | 0 .../SyntaxCLike/Annotations/3-annotation.lua | 4 ++ .../SyntaxCLike/Annotations/3-annotation.txt | 0 .../SyntaxCLike/Annotations/4-annotation.lua | 6 +++ .../SyntaxCLike/Annotations/4-annotation.txt | 0 .../SyntaxCLike/Annotations/5-annotation.lua | 4 ++ .../SyntaxCLike/Annotations/5-annotation.txt | 0 .../EndToEnd/CLikeTestRunner.cs | 9 +++- 14 files changed, 113 insertions(+), 7 deletions(-) create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.lua create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.txt create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.lua create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.txt create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.lua create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.txt create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.lua create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.txt create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.lua create mode 100644 src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.txt diff --git a/src/MoonSharp.Interpreter/IAnnotationPolicy.cs b/src/MoonSharp.Interpreter/IAnnotationPolicy.cs index 9dd9af33..d01fddbb 100644 --- a/src/MoonSharp.Interpreter/IAnnotationPolicy.cs +++ b/src/MoonSharp.Interpreter/IAnnotationPolicy.cs @@ -1,5 +1,18 @@ namespace MoonSharp.Interpreter { + public enum AnnotationValueParsingPolicy + { + /// + /// Annotations are parsed as string @MyAnnotation("strValue") or as a table @MyAnnotation({"key1", "key2"}) + /// + StringOrTable, + /// + /// Annotations are always parsed as a table and curly brackes enclosing the table are relaxed. + /// In this mode @MyAnnotation("key1", "key2") is equivalent to @MyAnnotation({"key1", "key2"}) + /// + ForceTable + } + public enum AnnotationAction { Allow, @@ -11,8 +24,29 @@ public interface IAnnotationPolicy { AnnotationAction OnChunkAnnotation(string name, DynValue value); AnnotationAction OnFunctionAnnotation(string name, DynValue value); + AnnotationValueParsingPolicy AnnotationParsingPolicy { get; set; } } + public class CustomPolicy : IAnnotationPolicy + { + public CustomPolicy(AnnotationValueParsingPolicy parsingPolicy) + { + AnnotationParsingPolicy = parsingPolicy; + } + + public AnnotationAction OnChunkAnnotation(string name, DynValue value) + { + return AnnotationAction.Allow; + } + + public AnnotationAction OnFunctionAnnotation(string name, DynValue value) + { + return AnnotationAction.Allow; + } + + public AnnotationValueParsingPolicy AnnotationParsingPolicy { get; set; } + } + public static class AnnotationPolicies { public static IAnnotationPolicy Allow { get; } = new AllowPolicy(); @@ -20,7 +54,7 @@ public static class AnnotationPolicies public static IAnnotationPolicy Ignore { get; } = new IgnorePolicy(); public static IAnnotationPolicy Error { get; } = new ErrorPolicy(); - + class AllowPolicy : IAnnotationPolicy { public AnnotationAction OnChunkAnnotation(string name, DynValue value) @@ -32,6 +66,8 @@ public AnnotationAction OnFunctionAnnotation(string name, DynValue value) { return AnnotationAction.Allow; } + + public AnnotationValueParsingPolicy AnnotationParsingPolicy { get; set; } = AnnotationValueParsingPolicy.StringOrTable; } class IgnorePolicy : IAnnotationPolicy @@ -45,6 +81,8 @@ public AnnotationAction OnFunctionAnnotation(string name, DynValue value) { return AnnotationAction.Ignore; } + + public AnnotationValueParsingPolicy AnnotationParsingPolicy { get; set; } = AnnotationValueParsingPolicy.StringOrTable; } class ErrorPolicy : IAnnotationPolicy @@ -58,6 +96,8 @@ public AnnotationAction OnFunctionAnnotation(string name, DynValue value) { return AnnotationAction.Error; } + + public AnnotationValueParsingPolicy AnnotationParsingPolicy { get; set; } = AnnotationValueParsingPolicy.StringOrTable; } } } \ No newline at end of file diff --git a/src/MoonSharp.Interpreter/ScriptOptions.cs b/src/MoonSharp.Interpreter/ScriptOptions.cs index 901d3c4b..16f83640 100644 --- a/src/MoonSharp.Interpreter/ScriptOptions.cs +++ b/src/MoonSharp.Interpreter/ScriptOptions.cs @@ -119,6 +119,7 @@ internal ScriptOptions(ScriptOptions defaults) /// /// Gets or sets the annotation policy for the script compiler (C-Like mode only) + /// /// public IAnnotationPolicy AnnotationPolicy { get; set; } = AnnotationPolicies.Allow; diff --git a/src/MoonSharp.Interpreter/Tree/Statement.cs b/src/MoonSharp.Interpreter/Tree/Statement.cs index cd8dc5a1..93931779 100644 --- a/src/MoonSharp.Interpreter/Tree/Statement.cs +++ b/src/MoonSharp.Interpreter/Tree/Statement.cs @@ -51,26 +51,62 @@ static Annotation ParseAnnotation(ScriptLoadingContext lcontext) lcontext.Lexer.Next(); //Skip annotation marker var nameToken = CheckTokenType(lcontext, TokenType.Name); //name DynValue value = DynValue.Nil; - //value - if (lcontext.Lexer.Current.Type == TokenType.Brk_Open_Round) + + DynValue NextPart(bool next) { - lcontext.Lexer.Next(); + DynValue _value = DynValue.Nil; if (lcontext.Lexer.Current.Type != TokenType.Brk_Close_Round) { + if (next) + { + lcontext.Lexer.Next(); + } + var exprToken = lcontext.Lexer.Current; var expr = Expression.Expr(lcontext); if (expr is TableConstructor tbl) { - if(!tbl.TryGetLiteral(out value)) + if(!tbl.TryGetLiteral(out _value)) throw new SyntaxErrorException(exprToken, "annotation value must be literal or prime table"); } - else if (!expr.EvalLiteral(out value)) + else if (!expr.EvalLiteral(out _value)) { throw new SyntaxErrorException(exprToken, "annotation value must be literal or prime table"); } } + + return _value; + } + + if (lcontext.Lexer.Current.Type == TokenType.Brk_Open_Round) + { + value = NextPart(true); + + if (lcontext.Script.Options.AnnotationPolicy.AnnotationParsingPolicy == AnnotationValueParsingPolicy.StringOrTable || value.Type == DataType.Table) + { + CheckTokenType(lcontext, TokenType.Brk_Close_Round); + return new Annotation(nameToken.Text, value); + } + + DynValue table = DynValue.NewTable(lcontext.Script); + table.Table.Append(value); + + while (true) + { + if (lcontext.Lexer.Current.Type == TokenType.Brk_Close_Round) + { + break; + } + + CheckTokenType(lcontext, TokenType.Comma); + value = NextPart(false); + table.Table.Append(value); + } + CheckTokenType(lcontext, TokenType.Brk_Close_Round); + return new Annotation(nameToken.Text, table); } + return new Annotation(nameToken.Text, value); } diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.lua b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.lua new file mode 100644 index 00000000..b5aa39f4 --- /dev/null +++ b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.lua @@ -0,0 +1,4 @@ +@bind("html-name", "cool") +function f() { + +} \ No newline at end of file diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.txt b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.txt new file mode 100644 index 00000000..e69de29b diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.lua b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.lua new file mode 100644 index 00000000..50b5497a --- /dev/null +++ b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.lua @@ -0,0 +1,4 @@ +@bind("html-name") +function f() { + +} \ No newline at end of file diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.txt b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.txt new file mode 100644 index 00000000..e69de29b diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.lua b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.lua new file mode 100644 index 00000000..1b50d7c1 --- /dev/null +++ b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.lua @@ -0,0 +1,4 @@ +@bind +function f() { + +} \ No newline at end of file diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.txt b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.txt new file mode 100644 index 00000000..e69de29b diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.lua b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.lua new file mode 100644 index 00000000..377832fe --- /dev/null +++ b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.lua @@ -0,0 +1,6 @@ +@bind("tbl1") +@bind2({"tbl2", "tbl3"}) +@bind3("tbl4", "tbl6") +function f() { + +} \ No newline at end of file diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.txt b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.txt new file mode 100644 index 00000000..e69de29b diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.lua b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.lua new file mode 100644 index 00000000..1ec81f9c --- /dev/null +++ b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.lua @@ -0,0 +1,4 @@ +@bind2({"tbl2", "tbl3"}) +function f() { + +} \ No newline at end of file diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.txt b/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.txt new file mode 100644 index 00000000..e69de29b diff --git a/src/MoonSharp.Tests/EndToEnd/CLikeTestRunner.cs b/src/MoonSharp.Tests/EndToEnd/CLikeTestRunner.cs index 988ca721..ad98a6b7 100644 --- a/src/MoonSharp.Tests/EndToEnd/CLikeTestRunner.cs +++ b/src/MoonSharp.Tests/EndToEnd/CLikeTestRunner.cs @@ -1,4 +1,5 @@ using System; +using System.Collections.Generic; using System.IO; using System.Text; using System.Threading.Tasks; @@ -35,6 +36,7 @@ public async Task Run(string path) Script script = new Script(CoreModules.Preset_HardSandbox); script.Options.DebugPrint = s => stdOut.AppendLine(s); script.Options.IndexTablesFrom = 0; + script.Options.AnnotationPolicy = new CustomPolicy(AnnotationValueParsingPolicy.ForceTable); if (path.Contains("SyntaxCLike")) { @@ -49,7 +51,12 @@ public async Task Run(string path) try { - await script.DoStringAsync(code); + DynValue dv = script.LoadString(code); + IReadOnlyList annots = dv.Function.Annotations; + await script.CallAsync(dv); + + DynValue dv2 = script.Globals.Get("f"); + Assert.AreEqual(output.Trim(), stdOut.ToString().Trim(), $"Test {path} did not pass."); if (path.Contains("invalid")) From 33fc4e41bb454fbeb8f33615af29623b17cc669a Mon Sep 17 00:00:00 2001 From: Callum Date: Tue, 12 Apr 2022 11:31:51 +0930 Subject: [PATCH 003/164] Change CI branch to main --- .github/workflows/dotnet.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml index cb3c971b..e1ce507e 100644 --- a/.github/workflows/dotnet.yml +++ b/.github/workflows/dotnet.yml @@ -2,9 +2,9 @@ name: .NET on: push: - branches: [ librelancer ] + branches: [ main ] pull_request: - branches: [ librelancer ] + branches: [ main ] jobs: build: From bc82544eb7eca195c9a30421f6587f75533a65da Mon Sep 17 00:00:00 2001 From: CallumDev Date: Tue, 12 Apr 2022 11:46:41 +0930 Subject: [PATCH 004/164] MoonSharp->WattleScript --- AUTHORS | 2 +- LICENSE | 4 +- .../Utils/GeneratorUtilities.cs | 19 ----- .../SourceGenerator.ClassNames.cs | 23 ------ .../Tree/Statements/IBlockStatement.cs | 9 --- src/MoonSharp/moonsharp.ico | Bin 370070 -> 0 bytes src/README.md | 10 +-- src/Tutorial/Tutorials/Chapters/Chapter1.cs | 4 +- src/Tutorial/Tutorials/Chapters/Chapter10.cs | 6 +- src/Tutorial/Tutorials/Chapters/Chapter11.cs | 8 +-- src/Tutorial/Tutorials/Chapters/Chapter12.cs | 8 +-- src/Tutorial/Tutorials/Chapters/Chapter2.cs | 6 +- src/Tutorial/Tutorials/Chapters/Chapter3.cs | 6 +- src/Tutorial/Tutorials/Chapters/Chapter4.cs | 2 +- src/Tutorial/Tutorials/Chapters/Chapter5.cs | 2 +- src/Tutorial/Tutorials/Chapters/Chapter6.cs | 58 +++++++-------- src/Tutorial/Tutorials/Chapters/Chapter7.cs | 2 +- src/Tutorial/Tutorials/Chapters/Chapter8.cs | 4 +- src/Tutorial/Tutorials/Chapters/Chapter9.cs | 6 +- src/Tutorial/Tutorials/Chapters/X1.cs | 4 +- src/Tutorial/Tutorials/Tutorials.csproj | 12 ++-- src/Tutorial/Tutorials/readme.md | 2 +- .../ArrayMemberDescriptorGenerator.cs | 14 ++-- ...AssignableMemberDescriptorGeneratorBase.cs | 10 +-- .../DynValueMemberDescriptorGenerator.cs | 10 +-- .../FieldMemberDescriptorGenerator.cs | 12 ++-- .../MethodMemberDescriptorGenerator.cs | 14 ++-- .../Generators/NullGenerator.cs | 4 +- ...erloadedMethodMemberDescriptorGenerator.cs | 10 +-- .../PropertyMemberDescriptorGenerator.cs | 12 ++-- .../StandardUserDataDescriptorGenerator.cs | 10 +-- ...ypeDefaultCtorMemberDescriptorGenerator.cs | 10 +-- .../HardwireCodeGenerationContext.cs | 8 +-- .../HardwireGenerator.cs | 6 +- .../HardwireGeneratorRegistry.cs | 6 +- .../ICodeGenerationLogger.cs | 2 +- .../IHardwireGenerator.cs | 4 +- .../IdGen.cs | 2 +- .../CSharpHardwireCodeGenerationLanguage.cs | 2 +- .../HardwireCodeGenerationLanguage.cs | 2 +- .../VbHardwireCodeGenerationLanguage.cs | 2 +- .../Utils/GeneratorUtilities.cs | 19 +++++ .../Utils/HardwireParameterDescriptor.cs | 8 +-- .../WattleScript.Hardwire.csproj} | 2 +- .../ExtraClassList.cs | 4 +- .../IdGen.cs | 2 +- .../SourceGenerator.ClassNames.cs | 23 ++++++ .../SourceGenerator.cs | 32 ++++----- .../StringUtils.cs | 2 +- .../SymbolUtils.cs | 2 +- .../TabbedWriter.cs | 2 +- .../TypeGenQueue.cs | 2 +- .../WattleScript.HardwireGen.csproj} | 0 .../AsyncExtensions.cs | 28 ++++---- .../CoreLib/BasicModule.cs | 24 +++---- .../CoreLib/Bit32Module.cs | 28 ++++---- .../CoreLib/CoroutineModule.cs | 16 ++--- .../CoreLib/DebugModule.cs | 34 ++++----- .../CoreLib/DynamicModule.cs | 12 ++-- .../CoreLib/ErrorHandlingModule.cs | 8 +-- .../CoreLib/IO/BinaryEncoding.cs | 2 +- .../CoreLib/IO/FileUserData.cs | 2 +- .../CoreLib/IO/FileUserDataBase.cs | 2 +- .../CoreLib/IO/StandardIOFileUserDataBase.cs | 2 +- .../CoreLib/IO/StreamFileUserDataBase.cs | 2 +- .../CoreLib/IoModule.cs | 30 ++++---- .../CoreLib/JsonModule.cs | 14 ++-- .../CoreLib/LoadModule.cs | 20 +++--- .../CoreLib/MathModule.cs | 66 ++++++++--------- .../CoreLib/MetaTableModule.cs | 16 ++--- .../CoreLib/OsSystemModule.cs | 18 ++--- .../CoreLib/OsTimeModule.cs | 12 ++-- .../CoreLib/StringLib/KopiLua_StrLib.cs | 4 +- .../CoreLib/StringLib/StringRange.cs | 2 +- .../CoreLib/StringModule.cs | 46 ++++++------ .../CoreLib/TableIteratorsModule.cs | 10 +-- .../CoreLib/TableModule.cs | 22 +++--- .../DataStructs/Extension_Methods.cs | 2 +- .../DataStructs/FastStack.cs | 2 +- .../DataStructs/LinkedListArrayIndex.cs | 2 +- .../DataStructs/LinkedListIndex.cs | 2 +- .../DataStructs/MultiDictionary.cs | 2 +- .../DataStructs/ReferenceEqualityComparer.cs | 2 +- .../DataStructs/Slice.cs | 2 +- .../DataTypes/Annotation.cs | 2 +- .../DataTypes/CallbackArguments.cs | 4 +- .../DataTypes/CallbackFunction.cs | 4 +- .../DataTypes/Closure.cs | 4 +- .../DataTypes/Coroutine.cs | 8 +-- .../DataTypes/CoroutineState.cs | 2 +- .../DataTypes/DataType.cs | 4 +- .../DataTypes/DynValue.cs | 26 +++---- .../DataTypes/IScriptPrivateResource.cs | 2 +- .../DataTypes/RefIdObject.cs | 4 +- .../DataTypes/ScriptFunctionDelegate.cs | 2 +- .../DataTypes/SymbolRef.cs | 4 +- .../DataTypes/SymbolRefType.cs | 2 +- .../DataTypes/Table.cs | 12 ++-- .../DataTypes/TablePair.cs | 2 +- .../DataTypes/TailCallData.cs | 2 +- .../DataTypes/TypeValidationFlags.cs | 2 +- .../DataTypes/UserData.cs | 18 ++--- .../DataTypes/WellKnownSymbols.cs | 4 +- .../DataTypes/YieldRequest.cs | 2 +- .../Debugging/DebugService.cs | 6 +- .../Debugging/DebuggerAction.cs | 2 +- .../Debugging/DebuggerCaps.cs | 2 +- .../Debugging/IDebugger.cs | 2 +- .../Debugging/SourceCode.cs | 2 +- .../Debugging/SourceRef.cs | 4 +- .../Debugging/WatchItem.cs | 2 +- .../Debugging/WatchType.cs | 2 +- .../Diagnostics/PerformanceCounter.cs | 2 +- .../Diagnostics/PerformanceCounterType.cs | 2 +- .../DummyPerformanceStopwatch.cs | 2 +- .../GlobalPerformanceStopwatch.cs | 2 +- .../IPerformanceStopwatch.cs | 2 +- .../PerformanceStopwatch.cs | 2 +- .../Diagnostics/PerformanceResult.cs | 2 +- .../Diagnostics/PerformanceStatistics.cs | 4 +- .../Errors/DynamicExpressionException.cs | 2 +- .../Errors/InternalErrorException.cs | 2 +- .../Errors/InterpreterException.cs | 8 +-- .../Errors/ScriptRuntimeException.cs | 8 +-- .../Errors/SyntaxErrorException.cs | 6 +- .../Execution/DynamicExpression.cs | 4 +- .../Execution/InstructionFieldUsage.cs | 4 +- .../Execution/Scopes/BuildTimeScope.cs | 8 +-- .../Execution/Scopes/BuildTimeScopeBlock.cs | 4 +- .../Execution/Scopes/BuildTimeScopeFrame.cs | 4 +- .../Execution/Scopes/ClosureContext.cs | 2 +- .../Execution/Scopes/IClosureBuilder.cs | 2 +- .../Execution/Scopes/LoopTracker.cs | 6 +- .../Execution/Scopes/RuntimeScopeBlock.cs | 2 +- .../Execution/Scopes/RuntimeScopeFrame.cs | 2 +- .../Execution/Scopes/Upvalue.cs | 4 +- .../Execution/ScriptExecutionContext.cs | 8 +-- .../Execution/ScriptLoadingContext.cs | 6 +- .../Execution/VM/ByteCode.cs | 4 +- .../Execution/VM/CallStackItem.cs | 4 +- .../Execution/VM/CallStackItemFlags.cs | 2 +- .../Execution/VM/ExecutionState.cs | 4 +- .../Execution/VM/Instruction.cs | 8 +-- .../Execution/VM/OpCode.cs | 4 +- .../Execution/VM/OpCodeMetadataType.cs | 2 +- .../Execution/VM/Processor/DebugContext.cs | 4 +- .../Execution/VM/Processor/Processor.cs | 10 +-- .../VM/Processor/Processor_BinaryDump.cs | 8 +-- .../VM/Processor/Processor_Coroutines.cs | 2 +- .../VM/Processor/Processor_Debugger.cs | 4 +- .../VM/Processor/Processor_Errors.cs | 4 +- .../Processor/Processor_IExecutionContext.cs | 2 +- .../VM/Processor/Processor_InstructionLoop.cs | 10 +-- .../Execution/VM/Processor/Processor_Scope.cs | 2 +- .../Processor/Processor_UtilityFunctions.cs | 2 +- .../IAnnotationPolicy.cs | 2 +- .../IO/BinDumpReader.cs | 2 +- .../IO/BinDumpWriter.cs | 2 +- .../Attributes/MoonSharpHiddenAttribute.cs | 6 +- .../MoonSharpHideMemberAttribute.cs | 8 +-- .../Attributes/MoonSharpPropertyAttribute.cs | 12 ++-- .../Attributes/MoonSharpUserDataAttribute.cs | 8 +-- .../MoonSharpUserDataMetamethodAttribute.cs | 8 +-- .../Attributes/MoonSharpVisibleAttribute.cs | 10 +-- .../DispatchingUserDataDescriptor.cs | 6 +- .../BasicDescriptors/IMemberDescriptor.cs | 2 +- .../IOptimizableDescriptor.cs | 2 +- .../IOverloadableMemberDescriptor.cs | 2 +- .../MemberDescriptorAccess.cs | 2 +- .../BasicDescriptors/ParameterDescriptor.cs | 2 +- .../Converters/ClrToScriptConversions.cs | 10 +-- .../Interop/Converters/NumericConversions.cs | 2 +- .../Converters/ScriptToClrConversions.cs | 2 +- .../Interop/Converters/StringConversions.cs | 2 +- .../Interop/Converters/TableConversions.cs | 2 +- .../Interop/CustomConvertersCollection.cs | 4 +- .../Interop/DescriptorHelpers.cs | 18 ++--- .../Interop/IGeneratorUserDataDescriptor.cs | 2 +- .../Interop/IUserDataDescriptor.cs | 4 +- .../Interop/IUserDataMemberDescriptor.cs | 2 +- .../Interop/IUserDataType.cs | 2 +- .../Interop/IWireableDescriptor.cs | 2 +- .../Interop/InteropAccessMode.cs | 8 +-- .../Interop/InteropRegistrationPolicy.cs | 8 +-- .../Interop/LuaStateInterop/CharPtr.cs | 2 +- .../Interop/LuaStateInterop/LuaBase.cs | 2 +- .../Interop/LuaStateInterop/LuaBase_CLib.cs | 2 +- .../Interop/LuaStateInterop/LuaLBuffer.cs | 2 +- .../Interop/LuaStateInterop/LuaState.cs | 2 +- .../Interop/LuaStateInterop/Tools.cs | 2 +- .../Interop/PredefinedUserData/AnonWrapper.cs | 2 +- .../PredefinedUserData/EnumerableWrapper.cs | 4 +- .../Interop/PredefinedUserData/TaskWrapper.cs | 4 +- .../Interop/PropertyTableAssigner.cs | 10 +-- .../ProxyObjects/DelegateProxyFactory.cs | 2 +- .../Interop/ProxyObjects/IProxyFactory.cs | 2 +- .../Interop/ReflectionExtensions.cs | 2 +- .../Interop/ReflectionSpecialNames.cs | 2 +- .../AutomaticRegistrationPolicy.cs | 2 +- .../DefaultRegistrationPolicy.cs | 6 +- .../IRegistrationPolicy.cs | 2 +- .../PermanentRegistrationPolicy.cs | 2 +- .../AutoDescribingUserDataDescriptor.cs | 4 +- .../CompositeUserDataDescriptor.cs | 2 +- .../StandardDescriptors/EventFacade.cs | 2 +- .../HardwiredDescriptors/DefaultValue.cs | 2 +- .../HardwiredMemberDescriptor.cs | 6 +- .../HardwiredMethodMemberDescriptor.cs | 4 +- .../HardwiredUserDataDescriptor.cs | 4 +- .../ArrayMemberDescriptor.cs | 6 +- .../DynValueMemberDescriptor.cs | 4 +- .../FunctionMemberDescriptorBase.cs | 6 +- .../ObjectCallbackMemberDescriptor.cs | 6 +- .../ProxyUserDataDescriptor.cs | 2 +- .../EventMemberDescriptor.cs | 8 +-- .../FieldMemberDescriptor.cs | 8 +-- .../MethodMemberDescriptor.cs | 6 +- .../OverloadedMethodMemberDescriptor.cs | 6 +- .../PropertyMemberDescriptor.cs | 8 +-- .../ValueTypeDefaultCtorMemberDescriptor.cs | 6 +- .../StandardEnumUserDataDescriptor.cs | 4 +- .../StandardGenericsUserDataDescriptor.cs | 2 +- .../StandardUserDataDescriptor.cs | 10 +-- .../Interop/UserDataMemberType.cs | 2 +- .../ExtensionMethodsRegistry.cs | 6 +- .../TypeDescriptorRegistry.cs | 14 ++-- .../LinqHelpers.cs | 2 +- .../Loaders/EmbeddedResourcesScriptLoader.cs | 2 +- .../Loaders/FileSystemScriptLoader.cs | 2 +- .../Loaders/IScriptLoader.cs | 2 +- .../Loaders/InvalidScriptLoader.cs | 2 +- .../Loaders/ScriptLoaderBase.cs | 2 +- .../Loaders/UnityAssetsScriptLoader.cs | 10 +-- .../Modules/CoreModules.cs | 6 +- .../Modules/ModuleRegister.cs | 26 +++---- .../Modules/MoonSharpModuleAttribute.cs | 6 +- .../MoonSharpModuleConstantAttribute.cs | 6 +- .../Modules/MoonSharpModuleMethodAttribute.cs | 6 +- .../NameSpace_XmlHelp.cs | 24 +++---- .../Options/ColonOperatorBehaviour.cs | 2 +- .../Options/FuzzySymbolMatchingBehavior.cs | 2 +- .../Options/ScriptSyntax.cs | 2 +- .../Platforms/IPlatformAccessor.cs | 2 +- .../Platforms/LimitedPlatformAccessor.cs | 2 +- .../Platforms/PlatformAccessorBase.cs | 2 +- .../Platforms/PlatformAutoDetector.cs | 6 +- .../Platforms/StandardFileType.cs | 2 +- .../Platforms/StandardPlatformAccessor.cs | 4 +- .../REPL/ReplHistoryNavigator.cs | 2 +- .../REPL/ReplInterpreter.cs | 2 +- .../REPL/ReplInterpreterScriptLoader.cs | 4 +- .../Script.cs | 68 +++++++++--------- .../ScriptGlobalOptions.cs | 8 +-- .../ScriptOptions.cs | 14 ++-- .../Serialization/Json/JsonNull.cs | 6 +- .../Serialization/Json/JsonTableConverter.cs | 4 +- .../Serialization/ObjectValueConverter.cs | 6 +- .../Serialization/SerializationExtensions.cs | 2 +- .../Tree/Expression_.cs | 10 +-- .../Tree/Expressions/AdjustmentExpression.cs | 6 +- .../Expressions/BinaryOperatorExpression.cs | 8 +-- .../Tree/Expressions/DynamicExprExpression.cs | 6 +- .../Tree/Expressions/ExprListExpression.cs | 6 +- .../Expressions/FunctionCallExpression.cs | 8 +-- .../FunctionDefinitionExpression.cs | 12 ++-- .../Tree/Expressions/IndexExpression.cs | 8 +-- .../Tree/Expressions/LiteralExpression.cs | 6 +- .../Tree/Expressions/SymbolRefExpression.cs | 8 +-- .../Tree/Expressions/TableConstructor.cs | 6 +- .../Expressions/TemplatedStringExpression.cs | 6 +- .../Tree/Expressions/TernaryExpression.cs | 6 +- .../Expressions/UnaryOperatorExpression.cs | 8 +-- .../Tree/Fast_Interface/Loader_Fast.cs | 12 ++-- .../Tree/IVariable.cs | 4 +- .../Tree/Lexer/Lexer.cs | 2 +- .../Tree/Lexer/LexerUtils.cs | 2 +- .../Tree/Lexer/Token.cs | 2 +- .../Tree/Lexer/TokenType.cs | 2 +- .../Tree/Loop.cs | 6 +- .../Tree/NodeBase.cs | 6 +- .../Tree/Statement.cs | 8 +-- .../Tree/Statements/AssignmentStatement.cs | 8 +-- .../Tree/Statements/BreakStatement.cs | 8 +-- .../Tree/Statements/CStyleForStatement.cs | 10 +-- .../Tree/Statements/ChunkStatement.cs | 6 +- .../Tree/Statements/CompositeStatement.cs | 4 +- .../Tree/Statements/ContinueStatement.cs | 8 +-- .../Tree/Statements/DoBlockStatement.cs | 8 +-- .../Tree/Statements/EmptyStatement.cs | 4 +- .../Tree/Statements/ForEachLoopStatement.cs | 10 +-- .../Tree/Statements/ForLoopStatement.cs | 10 +-- .../Tree/Statements/ForRangeStatement.cs | 10 +-- .../Tree/Statements/FunctionCallStatement.cs | 8 +-- .../Statements/FunctionDefinitionStatement.cs | 8 +-- .../Tree/Statements/GotoStatement.cs | 8 +-- .../Tree/Statements/IBlockStatement.cs | 9 +++ .../Tree/Statements/IfStatement.cs | 8 +-- .../Tree/Statements/LabelStatement.cs | 6 +- .../Tree/Statements/RepeatStatement.cs | 8 +-- .../Tree/Statements/ReturnStatement.cs | 8 +-- .../Tree/Statements/WhileStatement.cs | 8 +-- .../WattleScript.Interpreter.csproj} | 0 .../EndToEnd/AsyncTests.cs | 2 +- .../EndToEnd/BinaryDumpTests.cs | 4 +- .../CLike/SyntaxCLike/Aliases/1-null.lua | 0 .../CLike/SyntaxCLike/Aliases/1-null.txt | 0 .../CLike/SyntaxCLike/Aliases/2-this.lua | 0 .../CLike/SyntaxCLike/Aliases/2-this.txt | 0 .../SyntaxCLike/Annotations/1-annotation.lua | 0 .../SyntaxCLike/Annotations/1-annotation.txt | 0 .../SyntaxCLike/Annotations/2-annotation.lua | 0 .../SyntaxCLike/Annotations/2-annotation.txt | 0 .../SyntaxCLike/Annotations/3-annotation.lua | 0 .../SyntaxCLike/Annotations/3-annotation.txt | 0 .../SyntaxCLike/Annotations/4-annotation.lua | 0 .../SyntaxCLike/Annotations/4-annotation.txt | 0 .../SyntaxCLike/Annotations/5-annotation.lua | 0 .../SyntaxCLike/Annotations/5-annotation.txt | 0 .../SyntaxCLike/Errors/1-common-invalid.lua | 0 .../SyntaxCLike/Errors/1-common-invalid.txt | 0 .../SyntaxCLike/Errors/2-resync-invalid.lua | 0 .../SyntaxCLike/Errors/2-resync-invalid.txt | 0 .../CLike/SyntaxCLike/Functions/1-call.lua | 0 .../CLike/SyntaxCLike/Functions/1-call.txt | 0 .../10-call-default-scope-local-3.lua | 0 .../10-call-default-scope-local-3.txt | 0 .../Functions/11-call-default-scope-arrow.lua | 0 .../Functions/11-call-default-scope-arrow.txt | 0 .../12-call-default-scope-arrow-invalid.lua | 0 .../12-call-default-scope-arrow-invalid.txt | 0 .../13-call-default-scope-arrow-arrow.lua | 0 .../13-call-default-scope-arrow-arrow.txt | 0 ...call-default-scope-arrow-arrow-default.lua | 0 ...call-default-scope-arrow-arrow-default.txt | 0 ...ll-default-scope-arrow-arrow-default-2.lua | 0 ...ll-default-scope-arrow-arrow-default-2.txt | 0 .../Functions/16-default-call-closure.lua | 0 .../Functions/16-default-call-closure.txt | 0 .../SyntaxCLike/Functions/17-call-hoisted.lua | 0 .../SyntaxCLike/Functions/17-call-hoisted.txt | 0 .../SyntaxCLike/Functions/2-call-default.lua | 0 .../SyntaxCLike/Functions/2-call-default.txt | 0 .../Functions/3-call-default-invalid.lua | 0 .../Functions/3-call-default-invalid.txt | 0 .../Functions/4-call-default-2.lua | 0 .../Functions/4-call-default-2.txt | 0 .../Functions/5-call-default-3.lua | 0 .../Functions/5-call-default-3.txt | 0 .../Functions/6-call-default-local.lua | 0 .../Functions/6-call-default-local.txt | 0 .../Functions/7-call-default-scope.lua | 0 .../Functions/7-call-default-scope.txt | 0 .../Functions/8-call-default-scope-local.lua | 0 .../Functions/8-call-default-scope-local.txt | 0 .../9-call-default-scope-local-2.lua | 0 .../9-call-default-scope-local-2.txt | 0 .../0-null-coalescing-assignment-min.lua | 0 .../0-null-coalescing-assignment-min.txt | 0 .../1-null-coalescing-assignment-check.lua | 0 .../1-null-coalescing-assignment-check.txt | 0 .../Operators/10-relax-ternary-chain-2.lua | 0 .../Operators/10-relax-ternary-chain-2.txt | 0 .../Operators/11-nill-coalescing-inverse.lua | 0 .../Operators/11-nill-coalescing-inverse.txt | 0 .../12-nill-coalescing-assignment-inverse.lua | 0 .../12-nill-coalescing-assignment-inverse.txt | 0 ...-nill-coalescing-assignment-inverse-ok.lua | 0 ...-nill-coalescing-assignment-inverse-ok.txt | 0 .../2-null-coalescing-assignment-scope.lua | 0 .../2-null-coalescing-assignment-scope.txt | 0 .../3-null-coalescing-assignment-local.lua | 0 .../3-null-coalescing-assignment-local.txt | 0 ...null-coalescing-assignment-local-scope.lua | 0 ...null-coalescing-assignment-local-scope.txt | 0 ...ull-coalescing-assignment-ternary-skip.lua | 0 ...ull-coalescing-assignment-ternary-skip.txt | 0 ...ull-coalescing-assignment-ternary-exec.lua | 0 ...ull-coalescing-assignment-ternary-exec.txt | 0 .../SyntaxCLike/Operators/7-relax-ternary.lua | 0 .../SyntaxCLike/Operators/7-relax-ternary.txt | 0 .../Operators/8-relax-ternary-cmp.lua | 0 .../Operators/8-relax-ternary-cmp.txt | 0 .../Operators/9-relax-ternary-chain.lua | 0 .../Operators/9-relax-ternary-chain.txt | 0 .../EndToEnd/CLike/SyntaxLua/Tables/0-set.lua | 0 .../EndToEnd/CLike/SyntaxLua/Tables/0-set.txt | 0 .../CLike/SyntaxLua/Tables/01-set-double.lua | 0 .../CLike/SyntaxLua/Tables/01-set-double.txt | 0 .../CLike/SyntaxLua/Tables/1-iterate.lua | 0 .../CLike/SyntaxLua/Tables/1-iterate.txt | 0 .../SyntaxLua/Tables/10-concat-from-to.lua | 0 .../SyntaxLua/Tables/10-concat-from-to.txt | 0 .../CLike/SyntaxLua/Tables/2-insert.lua | 0 .../CLike/SyntaxLua/Tables/2-insert.txt | 0 .../CLike/SyntaxLua/Tables/3-sort-simple.lua | 0 .../CLike/SyntaxLua/Tables/3-sort-simple.txt | 0 .../CLike/SyntaxLua/Tables/4-remove.lua | 0 .../CLike/SyntaxLua/Tables/4-remove.txt | 0 .../CLike/SyntaxLua/Tables/5-remove-index.lua | 0 .../CLike/SyntaxLua/Tables/5-remove-index.txt | 0 .../Tables/6-remove-index-multiple.lua | 0 .../Tables/6-remove-index-multiple.txt | 0 .../CLike/SyntaxLua/Tables/7-concat.lua | 0 .../CLike/SyntaxLua/Tables/7-concat.txt | 0 .../CLike/SyntaxLua/Tables/8-concat-from.lua | 0 .../CLike/SyntaxLua/Tables/8-concat-from.txt | 0 .../EndToEnd/CLikeTestRunner.cs | 2 +- .../EndToEnd/CSyntaxTests.cs | 2 +- .../EndToEnd/ClosureTests.cs | 4 +- .../CollectionsBaseGenRegisteredTests.cs | 2 +- ...CollectionsBaseInterfGenRegisteredTests.cs | 2 +- .../EndToEnd/CollectionsRegisteredTests.cs | 2 +- .../EndToEnd/ConfigPropertyAssignerTests.cs | 18 ++--- .../EndToEnd/CoroutineTests.cs | 2 +- .../EndToEnd/DynamicTests.cs | 6 +- .../EndToEnd/ErrorHandlingTests.cs | 2 +- .../EndToEnd/FunctionTests.cs | 2 +- .../EndToEnd/GotoTests.cs | 2 +- .../EndToEnd/JsonSerializationTests.cs | 6 +- .../EndToEnd/LuaTestSuiteExtract.cs | 6 +- .../EndToEnd/MetatableTests.cs | 6 +- .../EndToEnd/ProxyObjectsTests.cs | 8 +-- .../EndToEnd/SimpleTests.cs | 6 +- .../EndToEnd/StringLibTests.cs | 2 +- .../EndToEnd/StructAssignmentTechnique.cs | 4 +- .../EndToEnd/TableTests.cs | 6 +- .../EndToEnd/TailCallTests.cs | 4 +- .../EndToEnd/UserDataEnumsTest.cs | 2 +- .../EndToEnd/UserDataEventsTests.cs | 2 +- .../EndToEnd/UserDataFieldsTests.cs | 2 +- .../EndToEnd/UserDataIndexerTests.cs | 2 +- .../EndToEnd/UserDataMetaTests.cs | 20 +++--- .../EndToEnd/UserDataMethodsTests.cs | 4 +- .../EndToEnd/UserDataNestedTypesTests.cs | 6 +- .../EndToEnd/UserDataOverloadsTests.cs | 6 +- .../EndToEnd/UserDataPropertiesTests.cs | 8 +-- .../EndToEnd/Utils.cs | 2 +- .../EndToEnd/VarargsTupleTests.cs | 2 +- .../EndToEnd/VtUserDataFieldsTests.cs | 2 +- .../EndToEnd/VtUserDataIndexerTests.cs | 2 +- .../EndToEnd/VtUserDataMetaTests.cs | 20 +++--- .../EndToEnd/VtUserDataMethodsTests.cs | 4 +- .../EndToEnd/VtUserDataOverloadsTests.cs | 2 +- .../EndToEnd/VtUserDataPropertiesTests.cs | 8 +-- .../TapRunner.cs | 10 +-- .../TestMore/000-sanity.t | 0 .../TestMore/001-if.t | 0 .../TestMore/002-table.t | 0 .../TestMore/011-while.t | 0 .../TestMore/012-repeat.t | 0 .../TestMore/014-fornum.t | 0 .../TestMore/015-forlist.t | 0 .../TestMore/101-boolean.t | 0 .../TestMore/102-function.t | 0 .../TestMore/103-nil.t | 0 .../TestMore/104-number.t | 0 .../TestMore/105-string.t | 0 .../TestMore/106-table.t | 0 .../TestMore/107-thread.t | 0 .../TestMore/108-userdata.t | 0 .../TestMore/200-examples.t | 0 .../TestMore/201-assign.t | 0 .../TestMore/202-expr.t | 0 .../TestMore/203-lexico.t | 0 .../TestMore/204-grammar.t | 0 .../TestMore/211-scope.t | 0 .../TestMore/212-function.t | 0 .../TestMore/213-closure.t | 0 .../TestMore/214-coroutine.t | 0 .../TestMore/221-table.t | 0 .../TestMore/222-constructor.t | 0 .../TestMore/223-iterator.t | 0 .../TestMore/231-metatable.t | 0 .../TestMore/232-object.t | 0 .../TestMore/301-basic.t | 8 +-- .../TestMore/304-string.t | 2 +- .../TestMore/305-table.t | 2 +- .../TestMore/306-math.t | 2 +- .../TestMore/307-bit.t | 0 .../TestMore/308-io.t | 0 .../TestMore/309-os.t | 0 .../TestMore/310-debug.t | 0 .../TestMore/314-regex.t | 0 .../TestMore/320-stdin.t | 0 .../TestMore/Makefile | 0 .../TestMore/Modules/Test/Builder.lua | 0 .../TestMore/Modules/Test/More.lua | 0 .../TestMore/makefile.mak | 0 .../TestMoreTests.cs | 2 +- .../TestRunner.cs | 2 +- .../TestScript.cs | 4 +- .../WattleScript.Tests.csproj} | 2 +- src/{MoonSharp.sln => WattleScript.sln} | 10 +-- .../Commands/CommandManager.cs | 2 +- .../Commands/ICommand.cs | 2 +- .../Implementations/CompileCommand.cs | 4 +- .../Implementations/DumpBytecodeCommand.cs | 4 +- .../Commands/Implementations/ExitCommand.cs | 2 +- .../Implementations/HardWireCommand.cs | 8 +-- .../Commands/Implementations/HelpCommand.cs | 2 +- .../Implementations/RegisterCommand.cs | 4 +- .../Commands/Implementations/RunCommand.cs | 2 +- src/{MoonSharp => WattleScript}/Program.cs | 22 +++--- .../ShellContext.cs | 4 +- .../WattleScript.csproj} | 4 +- src/WattleScript/wattlescript.ico | Bin 0 -> 285478 bytes 506 files changed, 1168 insertions(+), 1170 deletions(-) delete mode 100644 src/MoonSharp.Hardwire/Utils/GeneratorUtilities.cs delete mode 100644 src/MoonSharp.HardwireGen/SourceGenerator.ClassNames.cs delete mode 100644 src/MoonSharp.Interpreter/Tree/Statements/IBlockStatement.cs delete mode 100644 src/MoonSharp/moonsharp.ico rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Generators/ArrayMemberDescriptorGenerator.cs (82%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Generators/Base/AssignableMemberDescriptorGeneratorBase.cs (94%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Generators/DynValueMemberDescriptorGenerator.cs (89%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Generators/FieldMemberDescriptorGenerator.cs (59%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Generators/MethodMemberDescriptorGenerator.cs (97%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Generators/NullGenerator.cs (89%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Generators/OverloadedMethodMemberDescriptorGenerator.cs (78%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Generators/PropertyMemberDescriptorGenerator.cs (59%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Generators/StandardUserDataDescriptorGenerator.cs (87%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Generators/ValueTypeDefaultCtorMemberDescriptorGenerator.cs (72%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/HardwireCodeGenerationContext.cs (97%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/HardwireGenerator.cs (92%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/HardwireGeneratorRegistry.cs (91%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/ICodeGenerationLogger.cs (88%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/IHardwireGenerator.cs (94%) rename src/{MoonSharp.HardwireGen => WattleScript.Hardwire}/IdGen.cs (97%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Languages/CSharpHardwireCodeGenerationLanguage.cs (97%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Languages/HardwireCodeGenerationLanguage.cs (97%) rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Languages/VbHardwireCodeGenerationLanguage.cs (97%) create mode 100644 src/WattleScript.Hardwire/Utils/GeneratorUtilities.cs rename src/{MoonSharp.Hardwire => WattleScript.Hardwire}/Utils/HardwireParameterDescriptor.cs (91%) rename src/{MoonSharp.Hardwire/MoonSharp.Hardwire.csproj => WattleScript.Hardwire/WattleScript.Hardwire.csproj} (74%) rename src/{MoonSharp.HardwireGen => WattleScript.HardwireGen}/ExtraClassList.cs (95%) rename src/{MoonSharp.Hardwire => WattleScript.HardwireGen}/IdGen.cs (97%) create mode 100644 src/WattleScript.HardwireGen/SourceGenerator.ClassNames.cs rename src/{MoonSharp.HardwireGen => WattleScript.HardwireGen}/SourceGenerator.cs (94%) rename src/{MoonSharp.HardwireGen => WattleScript.HardwireGen}/StringUtils.cs (90%) rename src/{MoonSharp.HardwireGen => WattleScript.HardwireGen}/SymbolUtils.cs (97%) rename src/{MoonSharp.HardwireGen => WattleScript.HardwireGen}/TabbedWriter.cs (97%) rename src/{MoonSharp.HardwireGen => WattleScript.HardwireGen}/TypeGenQueue.cs (94%) rename src/{MoonSharp.HardwireGen/MoonSharp.HardwireGen.csproj => WattleScript.HardwireGen/WattleScript.HardwireGen.csproj} (100%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/AsyncExtensions.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/BasicModule.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/Bit32Module.cs (93%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/CoroutineModule.cs (92%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/DebugModule.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/DynamicModule.cs (86%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/ErrorHandlingModule.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/IO/BinaryEncoding.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/IO/FileUserData.cs (93%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/IO/FileUserDataBase.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/IO/StandardIOFileUserDataBase.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/IO/StreamFileUserDataBase.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/IoModule.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/JsonModule.cs (83%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/LoadModule.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/MathModule.cs (89%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/MetaTableModule.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/OsSystemModule.cs (92%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/OsTimeModule.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/StringLib/KopiLua_StrLib.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/StringLib/StringRange.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/StringModule.cs (90%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/TableIteratorsModule.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/CoreLib/TableModule.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataStructs/Extension_Methods.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataStructs/FastStack.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataStructs/LinkedListArrayIndex.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataStructs/LinkedListIndex.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataStructs/MultiDictionary.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataStructs/ReferenceEqualityComparer.cs (89%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataStructs/Slice.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/Annotation.cs (91%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/CallbackArguments.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/CallbackFunction.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/Closure.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/Coroutine.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/CoroutineState.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/DataType.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/DynValue.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/IScriptPrivateResource.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/RefIdObject.cs (91%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/ScriptFunctionDelegate.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/SymbolRef.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/SymbolRefType.cs (93%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/Table.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/TablePair.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/TailCallData.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/TypeValidationFlags.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/UserData.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/WellKnownSymbols.cs (75%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/DataTypes/YieldRequest.cs (92%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Debugging/DebugService.cs (86%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Debugging/DebuggerAction.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Debugging/DebuggerCaps.cs (92%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Debugging/IDebugger.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Debugging/SourceCode.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Debugging/SourceRef.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Debugging/WatchItem.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Debugging/WatchType.cs (93%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Diagnostics/PerformanceCounter.cs (93%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Diagnostics/PerformanceCounterType.cs (88%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Diagnostics/PerformanceCounters/DummyPerformanceStopwatch.cs (89%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Diagnostics/PerformanceCounters/GlobalPerformanceStopwatch.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Diagnostics/PerformanceCounters/IPerformanceStopwatch.cs (65%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Diagnostics/PerformanceCounters/PerformanceStopwatch.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Diagnostics/PerformanceResult.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Diagnostics/PerformanceStatistics.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Errors/DynamicExpressionException.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Errors/InternalErrorException.cs (91%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Errors/InterpreterException.cs (91%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Errors/ScriptRuntimeException.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Errors/SyntaxErrorException.cs (93%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/DynamicExpression.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/InstructionFieldUsage.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/Scopes/BuildTimeScope.cs (93%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/Scopes/BuildTimeScopeBlock.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/Scopes/BuildTimeScopeFrame.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/Scopes/ClosureContext.cs (92%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/Scopes/IClosureBuilder.cs (72%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/Scopes/LoopTracker.cs (61%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/Scopes/RuntimeScopeBlock.cs (87%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/Scopes/RuntimeScopeFrame.cs (90%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/Scopes/Upvalue.cs (92%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/ScriptExecutionContext.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/ScriptLoadingContext.cs (83%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/ByteCode.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/CallStackItem.cs (87%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/CallStackItemFlags.cs (79%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/ExecutionState.cs (76%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/Instruction.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/OpCode.cs (91%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/OpCodeMetadataType.cs (78%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/Processor/DebugContext.cs (85%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/Processor/Processor.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/Processor/Processor_BinaryDump.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/Processor/Processor_Coroutines.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/Processor/Processor_Debugger.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/Processor/Processor_Errors.cs (86%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/Processor/Processor_IExecutionContext.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/Processor/Processor_InstructionLoop.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/Processor/Processor_Scope.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Execution/VM/Processor/Processor_UtilityFunctions.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/IAnnotationPolicy.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/IO/BinDumpReader.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/IO/BinDumpWriter.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/Attributes/MoonSharpHiddenAttribute.cs (66%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/Attributes/MoonSharpHideMemberAttribute.cs (67%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/Attributes/MoonSharpPropertyAttribute.cs (56%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/Attributes/MoonSharpUserDataAttribute.cs (67%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/Attributes/MoonSharpUserDataMetamethodAttribute.cs (64%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/Attributes/MoonSharpVisibleAttribute.cs (64%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/BasicDescriptors/DispatchingUserDataDescriptor.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/BasicDescriptors/IMemberDescriptor.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/BasicDescriptors/IOptimizableDescriptor.cs (88%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/BasicDescriptors/IOverloadableMemberDescriptor.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/BasicDescriptors/MemberDescriptorAccess.cs (86%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/BasicDescriptors/ParameterDescriptor.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/Converters/ClrToScriptConversions.cs (92%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/Converters/NumericConversions.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/Converters/ScriptToClrConversions.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/Converters/StringConversions.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/Converters/TableConversions.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/CustomConvertersCollection.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/DescriptorHelpers.cs (89%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/IGeneratorUserDataDescriptor.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/IUserDataDescriptor.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/IUserDataMemberDescriptor.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/IUserDataType.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/IWireableDescriptor.cs (88%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/InteropAccessMode.cs (86%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/InteropRegistrationPolicy.cs (82%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/LuaStateInterop/CharPtr.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/LuaStateInterop/LuaBase.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/LuaStateInterop/LuaBase_CLib.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/LuaStateInterop/LuaLBuffer.cs (85%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/LuaStateInterop/LuaState.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/LuaStateInterop/Tools.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/PredefinedUserData/AnonWrapper.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/PredefinedUserData/EnumerableWrapper.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/PredefinedUserData/TaskWrapper.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/PropertyTableAssigner.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/ProxyObjects/DelegateProxyFactory.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/ProxyObjects/IProxyFactory.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/ReflectionExtensions.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/ReflectionSpecialNames.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/RegistrationPolicies/AutomaticRegistrationPolicy.cs (90%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/RegistrationPolicies/DefaultRegistrationPolicy.cs (85%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/RegistrationPolicies/IRegistrationPolicy.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/RegistrationPolicies/PermanentRegistrationPolicy.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/AutoDescribingUserDataDescriptor.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/CompositeUserDataDescriptor.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/EventFacade.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/HardwiredDescriptors/DefaultValue.cs (58%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMemberDescriptor.cs (87%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMethodMemberDescriptor.cs (86%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredUserDataDescriptor.cs (59%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/MemberDescriptors/ArrayMemberDescriptor.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/MemberDescriptors/DynValueMemberDescriptor.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/MemberDescriptors/FunctionMemberDescriptorBase.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/MemberDescriptors/ObjectCallbackMemberDescriptor.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/ProxyUserDataDescriptor.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/ReflectionMemberDescriptors/EventMemberDescriptor.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/ReflectionMemberDescriptors/FieldMemberDescriptor.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/ReflectionMemberDescriptors/MethodMemberDescriptor.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/ReflectionMemberDescriptors/OverloadedMethodMemberDescriptor.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/ReflectionMemberDescriptors/PropertyMemberDescriptor.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/ReflectionMemberDescriptors/ValueTypeDefaultCtorMemberDescriptor.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/StandardEnumUserDataDescriptor.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/StandardGenericsUserDataDescriptor.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/StandardDescriptors/StandardUserDataDescriptor.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/UserDataMemberType.cs (81%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/UserDataRegistries/ExtensionMethodsRegistry.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Interop/UserDataRegistries/TypeDescriptorRegistry.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/LinqHelpers.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Loaders/EmbeddedResourcesScriptLoader.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Loaders/FileSystemScriptLoader.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Loaders/IScriptLoader.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Loaders/InvalidScriptLoader.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Loaders/ScriptLoaderBase.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Loaders/UnityAssetsScriptLoader.cs (93%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Modules/CoreModules.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Modules/ModuleRegister.cs (85%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Modules/MoonSharpModuleAttribute.cs (87%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Modules/MoonSharpModuleConstantAttribute.cs (68%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Modules/MoonSharpModuleMethodAttribute.cs (76%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/NameSpace_XmlHelp.cs (80%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Options/ColonOperatorBehaviour.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Options/FuzzySymbolMatchingBehavior.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Options/ScriptSyntax.cs (93%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Platforms/IPlatformAccessor.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Platforms/LimitedPlatformAccessor.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Platforms/PlatformAccessorBase.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Platforms/PlatformAutoDetector.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Platforms/StandardFileType.cs (87%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Platforms/StandardPlatformAccessor.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/REPL/ReplHistoryNavigator.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/REPL/ReplInterpreter.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/REPL/ReplInterpreterScriptLoader.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Script.cs (92%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/ScriptGlobalOptions.cs (91%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/ScriptOptions.cs (91%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Serialization/Json/JsonNull.cs (84%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Serialization/Json/JsonTableConverter.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Serialization/ObjectValueConverter.cs (89%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Serialization/SerializationExtensions.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expression_.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/AdjustmentExpression.cs (83%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/BinaryOperatorExpression.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/DynamicExprExpression.cs (85%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/ExprListExpression.cs (87%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/FunctionCallExpression.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/FunctionDefinitionExpression.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/IndexExpression.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/LiteralExpression.cs (91%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/SymbolRefExpression.cs (93%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/TableConstructor.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/TemplatedStringExpression.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/TernaryExpression.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Expressions/UnaryOperatorExpression.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Fast_Interface/Loader_Fast.cs (92%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/IVariable.cs (64%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Lexer/Lexer.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Lexer/LexerUtils.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Lexer/Token.cs (99%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Lexer/TokenType.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Loop.cs (86%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/NodeBase.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statement.cs (98%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/AssignmentStatement.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/BreakStatement.cs (81%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/CStyleForStatement.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/ChunkStatement.cs (92%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/CompositeStatement.cs (97%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/ContinueStatement.cs (85%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/DoBlockStatement.cs (92%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/EmptyStatement.cs (74%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/ForEachLoopStatement.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/ForLoopStatement.cs (93%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/ForRangeStatement.cs (94%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/FunctionCallStatement.cs (80%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/FunctionDefinitionStatement.cs (95%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/GotoStatement.cs (86%) create mode 100644 src/WattleScript.Interpreter/Tree/Statements/IBlockStatement.cs rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/IfStatement.cs (96%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/LabelStatement.cs (92%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/RepeatStatement.cs (91%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/ReturnStatement.cs (86%) rename src/{MoonSharp.Interpreter => WattleScript.Interpreter}/Tree/Statements/WhileStatement.cs (92%) rename src/{MoonSharp.Interpreter/MoonSharp.Interpreter.csproj => WattleScript.Interpreter/WattleScript.Interpreter.csproj} (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/AsyncTests.cs (98%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/BinaryDumpTests.cs (98%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Aliases/1-null.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Aliases/1-null.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Aliases/2-this.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Aliases/2-this.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/1-call.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/1-call.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/10-call-default-scope-local-3.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/10-call-default-scope-local-3.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/11-call-default-scope-arrow.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/11-call-default-scope-arrow.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/12-call-default-scope-arrow-invalid.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/12-call-default-scope-arrow-invalid.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/13-call-default-scope-arrow-arrow.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/13-call-default-scope-arrow-arrow.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/14-call-default-scope-arrow-arrow-default.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/14-call-default-scope-arrow-arrow-default.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/15-call-default-scope-arrow-arrow-default-2.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/15-call-default-scope-arrow-arrow-default-2.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/16-default-call-closure.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/16-default-call-closure.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/17-call-hoisted.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/17-call-hoisted.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/2-call-default.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/2-call-default.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/3-call-default-invalid.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/3-call-default-invalid.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/4-call-default-2.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/4-call-default-2.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/5-call-default-3.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/5-call-default-3.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/6-call-default-local.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/6-call-default-local.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/7-call-default-scope.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/7-call-default-scope.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/8-call-default-scope-local.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/8-call-default-scope-local.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/9-call-default-scope-local-2.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Functions/9-call-default-scope-local-2.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/0-null-coalescing-assignment-min.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/0-null-coalescing-assignment-min.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/1-null-coalescing-assignment-check.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/1-null-coalescing-assignment-check.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/10-relax-ternary-chain-2.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/10-relax-ternary-chain-2.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/11-nill-coalescing-inverse.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/11-nill-coalescing-inverse.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/12-nill-coalescing-assignment-inverse.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/12-nill-coalescing-assignment-inverse.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/13-nill-coalescing-assignment-inverse-ok.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/13-nill-coalescing-assignment-inverse-ok.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/2-null-coalescing-assignment-scope.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/2-null-coalescing-assignment-scope.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/3-null-coalescing-assignment-local.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/3-null-coalescing-assignment-local.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/4-null-coalescing-assignment-local-scope.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/4-null-coalescing-assignment-local-scope.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/5-null-coalescing-assignment-ternary-skip.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/5-null-coalescing-assignment-ternary-skip.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/6-null-coalescing-assignment-ternary-exec.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/6-null-coalescing-assignment-ternary-exec.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/7-relax-ternary.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/7-relax-ternary.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/8-relax-ternary-cmp.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/8-relax-ternary-cmp.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/9-relax-ternary-chain.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxCLike/Operators/9-relax-ternary-chain.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/0-set.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/0-set.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/01-set-double.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/01-set-double.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/1-iterate.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/1-iterate.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/10-concat-from-to.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/10-concat-from-to.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/2-insert.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/2-insert.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/3-sort-simple.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/3-sort-simple.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/4-remove.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/4-remove.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/5-remove-index.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/5-remove-index.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/6-remove-index-multiple.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/6-remove-index-multiple.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/7-concat.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/7-concat.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/8-concat-from.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLike/SyntaxLua/Tables/8-concat-from.txt (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CLikeTestRunner.cs (98%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CSyntaxTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/ClosureTests.cs (98%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CollectionsBaseGenRegisteredTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CollectionsBaseInterfGenRegisteredTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CollectionsRegisteredTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/ConfigPropertyAssignerTests.cs (87%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/CoroutineTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/DynamicTests.cs (92%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/ErrorHandlingTests.cs (97%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/FunctionTests.cs (95%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/GotoTests.cs (98%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/JsonSerializationTests.cs (96%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/LuaTestSuiteExtract.cs (96%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/MetatableTests.cs (97%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/ProxyObjectsTests.cs (82%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/SimpleTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/StringLibTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/StructAssignmentTechnique.cs (94%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/TableTests.cs (98%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/TailCallTests.cs (96%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/UserDataEnumsTest.cs (98%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/UserDataEventsTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/UserDataFieldsTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/UserDataIndexerTests.cs (98%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/UserDataMetaTests.cs (95%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/UserDataMethodsTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/UserDataNestedTypesTests.cs (97%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/UserDataOverloadsTests.cs (98%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/UserDataPropertiesTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/Utils.cs (96%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/VarargsTupleTests.cs (97%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/VtUserDataFieldsTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/VtUserDataIndexerTests.cs (98%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/VtUserDataMetaTests.cs (95%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/VtUserDataMethodsTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/VtUserDataOverloadsTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/EndToEnd/VtUserDataPropertiesTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TapRunner.cs (88%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/000-sanity.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/001-if.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/002-table.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/011-while.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/012-repeat.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/014-fornum.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/015-forlist.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/101-boolean.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/102-function.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/103-nil.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/104-number.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/105-string.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/106-table.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/107-thread.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/108-userdata.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/200-examples.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/201-assign.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/202-expr.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/203-lexico.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/204-grammar.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/211-scope.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/212-function.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/213-closure.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/214-coroutine.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/221-table.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/222-constructor.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/223-iterator.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/231-metatable.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/232-object.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/301-basic.t (96%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/304-string.t (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/305-table.t (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/306-math.t (98%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/307-bit.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/308-io.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/309-os.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/310-debug.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/314-regex.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/320-stdin.t (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/Makefile (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/Modules/Test/Builder.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/Modules/Test/More.lua (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMore/makefile.mak (100%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestMoreTests.cs (99%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestRunner.cs (76%) rename src/{MoonSharp.Tests => WattleScript.Tests}/TestScript.cs (97%) rename src/{MoonSharp.Tests/MoonSharp.Tests.csproj => WattleScript.Tests/WattleScript.Tests.csproj} (89%) rename src/{MoonSharp.sln => WattleScript.sln} (86%) rename src/{MoonSharp => WattleScript}/Commands/CommandManager.cs (96%) rename src/{MoonSharp => WattleScript}/Commands/ICommand.cs (88%) rename src/{MoonSharp => WattleScript}/Commands/Implementations/CompileCommand.cs (91%) rename src/{MoonSharp => WattleScript}/Commands/Implementations/DumpBytecodeCommand.cs (92%) rename src/{MoonSharp => WattleScript}/Commands/Implementations/ExitCommand.cs (90%) rename src/{MoonSharp => WattleScript}/Commands/Implementations/HardWireCommand.cs (96%) rename src/{MoonSharp => WattleScript}/Commands/Implementations/HelpCommand.cs (97%) rename src/{MoonSharp => WattleScript}/Commands/Implementations/RegisterCommand.cs (91%) rename src/{MoonSharp => WattleScript}/Commands/Implementations/RunCommand.cs (92%) rename src/{MoonSharp => WattleScript}/Program.cs (88%) rename src/{MoonSharp => WattleScript}/ShellContext.cs (81%) rename src/{MoonSharp/MoonSharp.csproj => WattleScript/WattleScript.csproj} (52%) create mode 100644 src/WattleScript/wattlescript.ico diff --git a/AUTHORS b/AUTHORS index e7c607de..a5a5f6bb 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1,5 +1,5 @@ -# This is the list of MoonSharp's significant contributors. +# This is the list of WattleScript's significant contributors. # # This does not necessarily list everyone who has contributed code, # especially since many employees of one corporation may be contributing. diff --git a/LICENSE b/LICENSE index 5b1726e3..bf4da670 100755 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ BSD 3-Clause License -Copyright (c) 2014-2022 The MoonSharp Authors, as shown by the AUTHORS file. +Copyright (c) 2014-2022 The WattleScript Authors, as shown by the AUTHORS file. All rights reserved. Redistribution and use in source and binary forms, with or without @@ -30,5 +30,3 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Parts of the string library are based on the KopiLua project (https://github.com/NLua/KopiLua) Copyright (c) 2012 LoDC - -The MoonSharp icon is (c) Isaac, 2014-2015 diff --git a/src/MoonSharp.Hardwire/Utils/GeneratorUtilities.cs b/src/MoonSharp.Hardwire/Utils/GeneratorUtilities.cs deleted file mode 100644 index 85e03263..00000000 --- a/src/MoonSharp.Hardwire/Utils/GeneratorUtilities.cs +++ /dev/null @@ -1,19 +0,0 @@ -using System; -using System.CodeDom; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; - -namespace MoonSharp.Hardwire.Utils -{ - public class GeneratorUtilities - { - - - - - } -} diff --git a/src/MoonSharp.HardwireGen/SourceGenerator.ClassNames.cs b/src/MoonSharp.HardwireGen/SourceGenerator.ClassNames.cs deleted file mode 100644 index 001b6d8c..00000000 --- a/src/MoonSharp.HardwireGen/SourceGenerator.ClassNames.cs +++ /dev/null @@ -1,23 +0,0 @@ -namespace MoonSharp.HardwireGen -{ - public partial class HardwireSourceGenerator - { - private const string CLS_USERDATA = - "MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors.HardwiredUserDataDescriptor"; - - private const string CLS_OVERLOAD = "MoonSharp.Interpreter.Interop.OverloadedMethodMemberDescriptor"; - - private const string CLS_OVERLOAD_MEMBER = - "MoonSharp.Interpreter.Interop.BasicDescriptors.IOverloadableMemberDescriptor"; - - private const string CLS_PROP_FIELD = - "MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors.HardwiredMemberDescriptor"; - - private const string CLS_METHOD = - "MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors.HardwiredMethodMemberDescriptor"; - - private const string CLS_PARAMETER = "MoonSharp.Interpreter.Interop.BasicDescriptors.ParameterDescriptor"; - - - } -} \ No newline at end of file diff --git a/src/MoonSharp.Interpreter/Tree/Statements/IBlockStatement.cs b/src/MoonSharp.Interpreter/Tree/Statements/IBlockStatement.cs deleted file mode 100644 index 25bf9ff2..00000000 --- a/src/MoonSharp.Interpreter/Tree/Statements/IBlockStatement.cs +++ /dev/null @@ -1,9 +0,0 @@ -using MoonSharp.Interpreter.Debugging; - -namespace MoonSharp.Interpreter.Tree.Statements -{ - interface IBlockStatement - { - SourceRef End { get; } - } -} \ No newline at end of file diff --git a/src/MoonSharp/moonsharp.ico b/src/MoonSharp/moonsharp.ico deleted file mode 100644 index 5b2000dc6c04a8ceb24adddb1e90e5afafb8b1de..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 370070 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 diff --git a/src/README.md b/src/README.md index a03dbfcc..788cfce3 100644 --- a/src/README.md +++ b/src/README.md @@ -1,9 +1,9 @@ | File/Dir | Contents | | -------- | -------- | -| MoonSharp.Interpreter | The core project - the interpreter engine is here. | -| MoonSharp.Interpreter.Tests | Test suite, mostly end to end tests of various kinds | -| MoonSharp | Sources for the REPL interpreter | -| MoonSharpTests | Tests runner to run the tests suite outside of Visual Studio (mainly, to test in Mono). | -| MoonSharp.sln | The solution containing everything | +| WattleScript.Interpreter | The core project - the interpreter engine is here. | +| WattleScript.Interpreter.Tests | Test suite, mostly end to end tests of various kinds | +| WattleScript | Sources for the REPL interpreter | +| WattleScriptTests | Tests runner to run the tests suite outside of Visual Studio (mainly, to test in Mono). | +| WattleScript.sln | The solution containing everything | | README.md | This file | diff --git a/src/Tutorial/Tutorials/Chapters/Chapter1.cs b/src/Tutorial/Tutorials/Chapters/Chapter1.cs index df4acb2f..7eaa5891 100644 --- a/src/Tutorial/Tutorials/Chapters/Chapter1.cs +++ b/src/Tutorial/Tutorials/Chapters/Chapter1.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; +using WattleScript.Interpreter; namespace Tutorials.Chapters { @@ -11,7 +11,7 @@ namespace Tutorials.Chapters static class Chapter01 { [Tutorial] - public static double MoonSharpFactorial() + public static double WattleScriptFactorial() { string script = @" -- defines a factorial function diff --git a/src/Tutorial/Tutorials/Chapters/Chapter10.cs b/src/Tutorial/Tutorials/Chapters/Chapter10.cs index 88aac284..39ccce74 100644 --- a/src/Tutorial/Tutorials/Chapters/Chapter10.cs +++ b/src/Tutorial/Tutorials/Chapters/Chapter10.cs @@ -4,9 +4,9 @@ using System.Reflection; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Loaders; -using MoonSharp.Interpreter.Platforms; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Loaders; +using WattleScript.Interpreter.Platforms; namespace Tutorials.Chapters { diff --git a/src/Tutorial/Tutorials/Chapters/Chapter11.cs b/src/Tutorial/Tutorials/Chapters/Chapter11.cs index 6cda5fc5..fd0153dd 100644 --- a/src/Tutorial/Tutorials/Chapters/Chapter11.cs +++ b/src/Tutorial/Tutorials/Chapters/Chapter11.cs @@ -5,10 +5,10 @@ using System.Reflection; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Loaders; -using MoonSharp.Interpreter.Platforms; -using MoonSharp.RemoteDebugger; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Loaders; +using WattleScript.Interpreter.Platforms; +using WattleScript.RemoteDebugger; namespace Tutorials.Chapters { diff --git a/src/Tutorial/Tutorials/Chapters/Chapter12.cs b/src/Tutorial/Tutorials/Chapters/Chapter12.cs index 5930dd96..45eb03d0 100644 --- a/src/Tutorial/Tutorials/Chapters/Chapter12.cs +++ b/src/Tutorial/Tutorials/Chapters/Chapter12.cs @@ -5,10 +5,10 @@ using System.Reflection; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Loaders; -using MoonSharp.Interpreter.Platforms; -using MoonSharp.RemoteDebugger; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Loaders; +using WattleScript.Interpreter.Platforms; +using WattleScript.RemoteDebugger; namespace Tutorials.Chapters { diff --git a/src/Tutorial/Tutorials/Chapters/Chapter2.cs b/src/Tutorial/Tutorials/Chapters/Chapter2.cs index 977db0ca..d222d0d9 100644 --- a/src/Tutorial/Tutorials/Chapters/Chapter2.cs +++ b/src/Tutorial/Tutorials/Chapters/Chapter2.cs @@ -3,14 +3,14 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; +using WattleScript.Interpreter; namespace Tutorials.Chapters { [Tutorial] static class Chapter02 { - public static double MoonSharpFactorial() + public static double WattleScriptFactorial() { string scriptCode = @" -- defines a factorial function @@ -35,7 +35,7 @@ function fact (n) [Tutorial] - public static double MoonSharpFactorial2() + public static double WattleScriptFactorial2() { string scriptCode = @" -- defines a factorial function diff --git a/src/Tutorial/Tutorials/Chapters/Chapter3.cs b/src/Tutorial/Tutorials/Chapters/Chapter3.cs index 999859b3..55f5d2f4 100644 --- a/src/Tutorial/Tutorials/Chapters/Chapter3.cs +++ b/src/Tutorial/Tutorials/Chapters/Chapter3.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; +using WattleScript.Interpreter; namespace Tutorials.Chapters { @@ -11,7 +11,7 @@ namespace Tutorials.Chapters static class Chapter03 { [Tutorial] - public static double MoonSharpFactorial() + public static double WattleScriptFactorial() { string scriptCode = @" -- defines a factorial function @@ -35,7 +35,7 @@ function fact (n) } [Tutorial] - public static double MoonSharpFactorial2() + public static double WattleScriptFactorial2() { string scriptCode = @" -- defines a factorial function diff --git a/src/Tutorial/Tutorials/Chapters/Chapter4.cs b/src/Tutorial/Tutorials/Chapters/Chapter4.cs index fe1a5281..55c808d7 100644 --- a/src/Tutorial/Tutorials/Chapters/Chapter4.cs +++ b/src/Tutorial/Tutorials/Chapters/Chapter4.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; +using WattleScript.Interpreter; namespace Tutorials.Chapters { diff --git a/src/Tutorial/Tutorials/Chapters/Chapter5.cs b/src/Tutorial/Tutorials/Chapters/Chapter5.cs index f7fab864..02c0ef13 100644 --- a/src/Tutorial/Tutorials/Chapters/Chapter5.cs +++ b/src/Tutorial/Tutorials/Chapters/Chapter5.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; +using WattleScript.Interpreter; namespace Tutorials.Chapters { diff --git a/src/Tutorial/Tutorials/Chapters/Chapter6.cs b/src/Tutorial/Tutorials/Chapters/Chapter6.cs index bd134455..8a89cb8d 100644 --- a/src/Tutorial/Tutorials/Chapters/Chapter6.cs +++ b/src/Tutorial/Tutorials/Chapters/Chapter6.cs @@ -3,8 +3,8 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Interop; namespace Tutorials.Chapters { @@ -13,7 +13,7 @@ static class Chapter06 { #region UserData classes - [MoonSharpUserData] + [WattleScriptUserData] class MyClass { public event EventHandler SomethingHappened; @@ -37,7 +37,7 @@ public string ManipulateString(string input, ref string tobeconcat, out string l } } - [MoonSharpUserData] + [WattleScriptUserData] class MyClassStatic { public static double calcHypotenuse(double a, double b) @@ -78,19 +78,19 @@ public ArithmOperatorsTestClass(int value) public int Length { get { return 117; } } - [MoonSharpUserDataMetamethod("__concat")] + [WattleScriptUserDataMetamethod("__concat")] public static int Concat(ArithmOperatorsTestClass o, int v) { return o.Value + v; } - [MoonSharpUserDataMetamethod("__concat")] + [WattleScriptUserDataMetamethod("__concat")] public static int Concat(int v, ArithmOperatorsTestClass o) { return o.Value + v; } - [MoonSharpUserDataMetamethod("__concat")] + [WattleScriptUserDataMetamethod("__concat")] public static int Concat(ArithmOperatorsTestClass o1, ArithmOperatorsTestClass o2) { return o1.Value + o2.Value; @@ -141,14 +141,14 @@ public System.Collections.IEnumerator GetEnumerator() return (new List() { 1, 2, 3 }).GetEnumerator(); } - [MoonSharpUserDataMetamethod("__call")] + [WattleScriptUserDataMetamethod("__call")] public int DefaultMethod() { return -Value; } - [MoonSharpUserDataMetamethod("__pairs")] - [MoonSharpUserDataMetamethod("__ipairs")] + [WattleScriptUserDataMetamethod("__pairs")] + [WattleScriptUserDataMetamethod("__ipairs")] public System.Collections.IEnumerator Pairs() { return (new List() { @@ -171,7 +171,7 @@ public static double CallMyClass1() return obj.calcHypotenuse(3, 4); "; - // Automatically register all MoonSharpUserData types + // Automatically register all WattleScriptUserData types UserData.RegisterAssembly(); Script script = new Script(); @@ -214,7 +214,7 @@ static double MyClassStaticThroughInstance() return obj.calcHypotenuse(3, 4); "; - // Automatically register all MoonSharpUserData types + // Automatically register all WattleScriptUserData types UserData.RegisterAssembly(); Script script = new Script(); @@ -233,7 +233,7 @@ static double MyClassStaticThroughPlaceholder() return obj.calcHypotenuse(3, 4); "; - // Automatically register all MoonSharpUserData types + // Automatically register all WattleScriptUserData types UserData.RegisterAssembly(); Script script = new Script(); @@ -254,7 +254,7 @@ static string ByRefParams() return x, y, z "; - // Automatically register all MoonSharpUserData types + // Automatically register all WattleScriptUserData types UserData.RegisterAssembly(); Script script = new Script(); @@ -422,10 +422,10 @@ private void Method1() { } // Visible - it's public public void Method2() { } // Visible - it's private but forced visible by attribute - [MoonSharpVisible(true)] + [WattleScriptVisible(true)] private void Method3() { } // Not visible - it's public but forced hidden by attribute - [MoonSharpVisible(false)] + [WattleScriptVisible(false)] public void Method4() { } // Not visible - it's private @@ -433,10 +433,10 @@ public void Method4() { } // Visible - it's public public int Field2 = 0; // Visible - it's private but forced visible by attribute - [MoonSharpVisible(true)] + [WattleScriptVisible(true)] private int Field3 = 0; // Not visible - it's public but forced hidden by attribute - [MoonSharpVisible(false)] + [WattleScriptVisible(false)] public int Field4 = 0; // Not visible at all - it's private @@ -445,13 +445,13 @@ public void Method4() { } public int Property2 { get; set; } // Readonly - it's public, but the setter is private public int Property3 { get; private set; } - // Write only! - the MoonSharpVisible makes the getter hidden and the setter visible! - public int Property4 { [MoonSharpVisible(false)] get; [MoonSharpVisible(true)] private set; } - // Write only! - the MoonSharpVisible makes the whole property hidden but another attribute resets the setter as visible! - [MoonSharpVisible(false)] - public int Property5 { get; [MoonSharpVisible(true)] private set; } - // Not visible at all - the MoonSharpVisible hides everything - [MoonSharpVisible(false)] + // Write only! - the WattleScriptVisible makes the getter hidden and the setter visible! + public int Property4 { [WattleScriptVisible(false)] get; [WattleScriptVisible(true)] private set; } + // Write only! - the WattleScriptVisible makes the whole property hidden but another attribute resets the setter as visible! + [WattleScriptVisible(false)] + public int Property5 { get; [WattleScriptVisible(true)] private set; } + // Not visible at all - the WattleScriptVisible hides everything + [WattleScriptVisible(false)] public int Property6 { get; set; } // Not visible - it's private @@ -459,14 +459,14 @@ public void Method4() { } // Visible - it's public public event EventHandler Event2; // Visible - it's private but forced visible by attribute - [MoonSharpVisible(true)] + [WattleScriptVisible(true)] private event EventHandler Event3; // Not visible - it's public but forced hidden by attribute - [MoonSharpVisible(false)] + [WattleScriptVisible(false)] public event EventHandler Event4; // Not visible - visibility modifiers over add and remove are not currently supported! - [MoonSharpVisible(false)] - public event EventHandler Event5 { [MoonSharpVisible(true)] add { } [MoonSharpVisible(true)] remove { } } + [WattleScriptVisible(false)] + public event EventHandler Event5 { [WattleScriptVisible(true)] add { } [WattleScriptVisible(true)] remove { } } diff --git a/src/Tutorial/Tutorials/Chapters/Chapter7.cs b/src/Tutorial/Tutorials/Chapters/Chapter7.cs index 1d0ec1bc..1ecf8fc2 100644 --- a/src/Tutorial/Tutorials/Chapters/Chapter7.cs +++ b/src/Tutorial/Tutorials/Chapters/Chapter7.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; +using WattleScript.Interpreter; namespace Tutorials.Chapters { diff --git a/src/Tutorial/Tutorials/Chapters/Chapter8.cs b/src/Tutorial/Tutorials/Chapters/Chapter8.cs index 0407b240..f4d60faa 100644 --- a/src/Tutorial/Tutorials/Chapters/Chapter8.cs +++ b/src/Tutorial/Tutorials/Chapters/Chapter8.cs @@ -4,8 +4,8 @@ using System.Reflection; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Loaders; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Loaders; namespace Tutorials.Chapters { diff --git a/src/Tutorial/Tutorials/Chapters/Chapter9.cs b/src/Tutorial/Tutorials/Chapters/Chapter9.cs index 6d84d1c1..bb8e561b 100644 --- a/src/Tutorial/Tutorials/Chapters/Chapter9.cs +++ b/src/Tutorial/Tutorials/Chapters/Chapter9.cs @@ -4,9 +4,9 @@ using System.Reflection; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Loaders; -using MoonSharp.Interpreter.Platforms; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Loaders; +using WattleScript.Interpreter.Platforms; namespace Tutorials.Chapters { diff --git a/src/Tutorial/Tutorials/Chapters/X1.cs b/src/Tutorial/Tutorials/Chapters/X1.cs index c7617055..a56e006a 100644 --- a/src/Tutorial/Tutorials/Chapters/X1.cs +++ b/src/Tutorial/Tutorials/Chapters/X1.cs @@ -3,8 +3,8 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Debugging; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Debugging; namespace Tutorials.Chapters { diff --git a/src/Tutorial/Tutorials/Tutorials.csproj b/src/Tutorial/Tutorials/Tutorials.csproj index 898e7f00..4227e4d4 100644 --- a/src/Tutorial/Tutorials/Tutorials.csproj +++ b/src/Tutorial/Tutorials/Tutorials.csproj @@ -70,17 +70,17 @@ - + {88d2880c-a863-4b16-abef-f67bd1e98bd1} - MoonSharp.Interpreter.net40-client + WattleScript.Interpreter.net40-client - + {f9d383b9-2639-4738-a897-4d9f8801b8c9} - MoonSharp.RemoteDebugger.net40-client + WattleScript.RemoteDebugger.net40-client - + {37b5fc4b-dee0-4428-8c53-c005f52af4a5} - MoonSharp.VsCodeDebugger.net40-client + WattleScript.VsCodeDebugger.net40-client diff --git a/src/Tutorial/Tutorials/readme.md b/src/Tutorial/Tutorials/readme.md index 2c9b625a..dd8e3ba6 100644 --- a/src/Tutorial/Tutorials/readme.md +++ b/src/Tutorial/Tutorials/readme.md @@ -1,4 +1,4 @@ -MoonSharp Tutorials +WattleScript Tutorials =================== diff --git a/src/MoonSharp.Hardwire/Generators/ArrayMemberDescriptorGenerator.cs b/src/WattleScript.Hardwire/Generators/ArrayMemberDescriptorGenerator.cs similarity index 82% rename from src/MoonSharp.Hardwire/Generators/ArrayMemberDescriptorGenerator.cs rename to src/WattleScript.Hardwire/Generators/ArrayMemberDescriptorGenerator.cs index 5556a3cd..92aae4de 100644 --- a/src/MoonSharp.Hardwire/Generators/ArrayMemberDescriptorGenerator.cs +++ b/src/WattleScript.Hardwire/Generators/ArrayMemberDescriptorGenerator.cs @@ -3,19 +3,19 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Hardwire.Utils; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Serialization; +using WattleScript.Hardwire.Utils; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Serialization; -namespace MoonSharp.Hardwire.Generators +namespace WattleScript.Hardwire.Generators { public class ArrayMemberDescriptorGenerator : IHardwireGenerator { public string ManagedType { - get { return "MoonSharp.Interpreter.Interop.ArrayMemberDescriptor"; } + get { return "WattleScript.Interpreter.Interop.ArrayMemberDescriptor"; } } public CodeExpression[] Generate(string parent, Table table, HardwireCodeGenerationContext generatorContext, CodeTypeMemberCollection members) diff --git a/src/MoonSharp.Hardwire/Generators/Base/AssignableMemberDescriptorGeneratorBase.cs b/src/WattleScript.Hardwire/Generators/Base/AssignableMemberDescriptorGeneratorBase.cs similarity index 94% rename from src/MoonSharp.Hardwire/Generators/Base/AssignableMemberDescriptorGeneratorBase.cs rename to src/WattleScript.Hardwire/Generators/Base/AssignableMemberDescriptorGeneratorBase.cs index befb34a3..632d4514 100644 --- a/src/MoonSharp.Hardwire/Generators/Base/AssignableMemberDescriptorGeneratorBase.cs +++ b/src/WattleScript.Hardwire/Generators/Base/AssignableMemberDescriptorGeneratorBase.cs @@ -3,12 +3,12 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; -namespace MoonSharp.Hardwire.Generators +namespace WattleScript.Hardwire.Generators { abstract class AssignableMemberDescriptorGeneratorBase: IHardwireGenerator { diff --git a/src/MoonSharp.Hardwire/Generators/DynValueMemberDescriptorGenerator.cs b/src/WattleScript.Hardwire/Generators/DynValueMemberDescriptorGenerator.cs similarity index 89% rename from src/MoonSharp.Hardwire/Generators/DynValueMemberDescriptorGenerator.cs rename to src/WattleScript.Hardwire/Generators/DynValueMemberDescriptorGenerator.cs index 99d16455..f2324d53 100644 --- a/src/MoonSharp.Hardwire/Generators/DynValueMemberDescriptorGenerator.cs +++ b/src/WattleScript.Hardwire/Generators/DynValueMemberDescriptorGenerator.cs @@ -3,17 +3,17 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Serialization; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Serialization; -namespace MoonSharp.Hardwire.Generators +namespace WattleScript.Hardwire.Generators { public class DynValueMemberDescriptorGenerator : IHardwireGenerator { public string ManagedType { - get { return "MoonSharp.Interpreter.Interop.DynValueMemberDescriptor"; } + get { return "WattleScript.Interpreter.Interop.DynValueMemberDescriptor"; } } public CodeExpression[] Generate(string parent, Table table, HardwireCodeGenerationContext generatorContext, CodeTypeMemberCollection members) diff --git a/src/MoonSharp.Hardwire/Generators/FieldMemberDescriptorGenerator.cs b/src/WattleScript.Hardwire/Generators/FieldMemberDescriptorGenerator.cs similarity index 59% rename from src/MoonSharp.Hardwire/Generators/FieldMemberDescriptorGenerator.cs rename to src/WattleScript.Hardwire/Generators/FieldMemberDescriptorGenerator.cs index 0956db8a..9a9eb3b8 100644 --- a/src/MoonSharp.Hardwire/Generators/FieldMemberDescriptorGenerator.cs +++ b/src/WattleScript.Hardwire/Generators/FieldMemberDescriptorGenerator.cs @@ -3,18 +3,18 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; -namespace MoonSharp.Hardwire.Generators +namespace WattleScript.Hardwire.Generators { class FieldMemberDescriptorGenerator : AssignableMemberDescriptorGeneratorBase { public override string ManagedType { - get { return "MoonSharp.Interpreter.Interop.FieldMemberDescriptor"; } + get { return "WattleScript.Interpreter.Interop.FieldMemberDescriptor"; } } protected override CodeExpression GetMemberAccessExpression(CodeExpression thisObj, string name) diff --git a/src/MoonSharp.Hardwire/Generators/MethodMemberDescriptorGenerator.cs b/src/WattleScript.Hardwire/Generators/MethodMemberDescriptorGenerator.cs similarity index 97% rename from src/MoonSharp.Hardwire/Generators/MethodMemberDescriptorGenerator.cs rename to src/WattleScript.Hardwire/Generators/MethodMemberDescriptorGenerator.cs index c585284b..56988cf8 100644 --- a/src/MoonSharp.Hardwire/Generators/MethodMemberDescriptorGenerator.cs +++ b/src/WattleScript.Hardwire/Generators/MethodMemberDescriptorGenerator.cs @@ -3,13 +3,13 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Hardwire.Utils; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; +using WattleScript.Hardwire.Utils; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; -namespace MoonSharp.Hardwire.Generators +namespace WattleScript.Hardwire.Generators { class MethodMemberDescriptorGenerator : IHardwireGenerator { @@ -27,7 +27,7 @@ public MethodMemberDescriptorGenerator(string prefix) public string ManagedType { - get { return "MoonSharp.Interpreter.Interop.MethodMemberDescriptor"; } + get { return "WattleScript.Interpreter.Interop.MethodMemberDescriptor"; } } public CodeExpression[] Generate(string parent, Table table, HardwireCodeGenerationContext generator, CodeTypeMemberCollection members) diff --git a/src/MoonSharp.Hardwire/Generators/NullGenerator.cs b/src/WattleScript.Hardwire/Generators/NullGenerator.cs similarity index 89% rename from src/MoonSharp.Hardwire/Generators/NullGenerator.cs rename to src/WattleScript.Hardwire/Generators/NullGenerator.cs index 07989403..f39e5d8f 100644 --- a/src/MoonSharp.Hardwire/Generators/NullGenerator.cs +++ b/src/WattleScript.Hardwire/Generators/NullGenerator.cs @@ -3,9 +3,9 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter; +using WattleScript.Interpreter; -namespace MoonSharp.Hardwire.Generators +namespace WattleScript.Hardwire.Generators { internal class NullGenerator : IHardwireGenerator { diff --git a/src/MoonSharp.Hardwire/Generators/OverloadedMethodMemberDescriptorGenerator.cs b/src/WattleScript.Hardwire/Generators/OverloadedMethodMemberDescriptorGenerator.cs similarity index 78% rename from src/MoonSharp.Hardwire/Generators/OverloadedMethodMemberDescriptorGenerator.cs rename to src/WattleScript.Hardwire/Generators/OverloadedMethodMemberDescriptorGenerator.cs index d578edd2..e33de7a4 100644 --- a/src/MoonSharp.Hardwire/Generators/OverloadedMethodMemberDescriptorGenerator.cs +++ b/src/WattleScript.Hardwire/Generators/OverloadedMethodMemberDescriptorGenerator.cs @@ -3,17 +3,17 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Interop.BasicDescriptors; -namespace MoonSharp.Hardwire.Generators +namespace WattleScript.Hardwire.Generators { class OverloadedMethodMemberDescriptorGenerator : IHardwireGenerator { public string ManagedType { - get { return "MoonSharp.Interpreter.Interop.OverloadedMethodMemberDescriptor"; } + get { return "WattleScript.Interpreter.Interop.OverloadedMethodMemberDescriptor"; } } public CodeExpression[] Generate(string parent, Table table, HardwireCodeGenerationContext generator, diff --git a/src/MoonSharp.Hardwire/Generators/PropertyMemberDescriptorGenerator.cs b/src/WattleScript.Hardwire/Generators/PropertyMemberDescriptorGenerator.cs similarity index 59% rename from src/MoonSharp.Hardwire/Generators/PropertyMemberDescriptorGenerator.cs rename to src/WattleScript.Hardwire/Generators/PropertyMemberDescriptorGenerator.cs index 34bd7699..b128df32 100644 --- a/src/MoonSharp.Hardwire/Generators/PropertyMemberDescriptorGenerator.cs +++ b/src/WattleScript.Hardwire/Generators/PropertyMemberDescriptorGenerator.cs @@ -3,18 +3,18 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; -namespace MoonSharp.Hardwire.Generators +namespace WattleScript.Hardwire.Generators { class PropertyMemberDescriptorGenerator : AssignableMemberDescriptorGeneratorBase { public override string ManagedType { - get { return "MoonSharp.Interpreter.Interop.PropertyMemberDescriptor"; } + get { return "WattleScript.Interpreter.Interop.PropertyMemberDescriptor"; } } protected override CodeExpression GetMemberAccessExpression(CodeExpression thisObj, string name) diff --git a/src/MoonSharp.Hardwire/Generators/StandardUserDataDescriptorGenerator.cs b/src/WattleScript.Hardwire/Generators/StandardUserDataDescriptorGenerator.cs similarity index 87% rename from src/MoonSharp.Hardwire/Generators/StandardUserDataDescriptorGenerator.cs rename to src/WattleScript.Hardwire/Generators/StandardUserDataDescriptorGenerator.cs index af394833..c793dda5 100644 --- a/src/MoonSharp.Hardwire/Generators/StandardUserDataDescriptorGenerator.cs +++ b/src/WattleScript.Hardwire/Generators/StandardUserDataDescriptorGenerator.cs @@ -3,17 +3,17 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; -namespace MoonSharp.Hardwire.Generators +namespace WattleScript.Hardwire.Generators { public class StandardUserDataDescriptorGenerator : IHardwireGenerator { public string ManagedType { - get { return "MoonSharp.Interpreter.Interop.StandardUserDataDescriptor"; } + get { return "WattleScript.Interpreter.Interop.StandardUserDataDescriptor"; } } public CodeExpression[] Generate(string parent, Table table, HardwireCodeGenerationContext generator, diff --git a/src/MoonSharp.Hardwire/Generators/ValueTypeDefaultCtorMemberDescriptorGenerator.cs b/src/WattleScript.Hardwire/Generators/ValueTypeDefaultCtorMemberDescriptorGenerator.cs similarity index 72% rename from src/MoonSharp.Hardwire/Generators/ValueTypeDefaultCtorMemberDescriptorGenerator.cs rename to src/WattleScript.Hardwire/Generators/ValueTypeDefaultCtorMemberDescriptorGenerator.cs index 6912b952..d196b947 100644 --- a/src/MoonSharp.Hardwire/Generators/ValueTypeDefaultCtorMemberDescriptorGenerator.cs +++ b/src/WattleScript.Hardwire/Generators/ValueTypeDefaultCtorMemberDescriptorGenerator.cs @@ -3,17 +3,17 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; -namespace MoonSharp.Hardwire.Generators +namespace WattleScript.Hardwire.Generators { class ValueTypeDefaultCtorMemberDescriptorGenerator : IHardwireGenerator { public string ManagedType { - get { return "MoonSharp.Interpreter.Interop.ValueTypeDefaultCtorMemberDescriptor"; } + get { return "WattleScript.Interpreter.Interop.ValueTypeDefaultCtorMemberDescriptor"; } } public CodeExpression[] Generate(string parent, Table table, HardwireCodeGenerationContext generator, CodeTypeMemberCollection members) diff --git a/src/MoonSharp.Hardwire/HardwireCodeGenerationContext.cs b/src/WattleScript.Hardwire/HardwireCodeGenerationContext.cs similarity index 97% rename from src/MoonSharp.Hardwire/HardwireCodeGenerationContext.cs rename to src/WattleScript.Hardwire/HardwireCodeGenerationContext.cs index 8687cf94..f86ca09b 100644 --- a/src/MoonSharp.Hardwire/HardwireCodeGenerationContext.cs +++ b/src/WattleScript.Hardwire/HardwireCodeGenerationContext.cs @@ -6,10 +6,10 @@ using System.Linq; using System.Reflection; using System.Text; -using MoonSharp.Hardwire.Languages; -using MoonSharp.Interpreter; +using WattleScript.Hardwire.Languages; +using WattleScript.Interpreter; -namespace MoonSharp.Hardwire +namespace WattleScript.Hardwire { /// /// The context under which code is generated. @@ -47,7 +47,7 @@ internal HardwireCodeGenerationContext(string namespaceName, string entryClassNa CompileUnit.Namespaces.Add(m_Namespace); Comment("----------------------------------------------------------"); - Comment("Compatible with MoonSharp v.{0} or equivalent", Script.VERSION); + Comment("Compatible with WattleScript v.{0} or equivalent", Script.VERSION); Comment("----------------------------------------------------------"); string[] extraComments = language.GetInitialComment(); diff --git a/src/MoonSharp.Hardwire/HardwireGenerator.cs b/src/WattleScript.Hardwire/HardwireGenerator.cs similarity index 92% rename from src/MoonSharp.Hardwire/HardwireGenerator.cs rename to src/WattleScript.Hardwire/HardwireGenerator.cs index 68a4cad8..ab4417b7 100644 --- a/src/MoonSharp.Hardwire/HardwireGenerator.cs +++ b/src/WattleScript.Hardwire/HardwireGenerator.cs @@ -5,10 +5,10 @@ using System.IO; using System.Linq; using System.Text; -using MoonSharp.Hardwire.Languages; -using MoonSharp.Interpreter; +using WattleScript.Hardwire.Languages; +using WattleScript.Interpreter; -namespace MoonSharp.Hardwire +namespace WattleScript.Hardwire { public class HardwireGenerator { diff --git a/src/MoonSharp.Hardwire/HardwireGeneratorRegistry.cs b/src/WattleScript.Hardwire/HardwireGeneratorRegistry.cs similarity index 91% rename from src/MoonSharp.Hardwire/HardwireGeneratorRegistry.cs rename to src/WattleScript.Hardwire/HardwireGeneratorRegistry.cs index 830c244c..1cdabaf9 100644 --- a/src/MoonSharp.Hardwire/HardwireGeneratorRegistry.cs +++ b/src/WattleScript.Hardwire/HardwireGeneratorRegistry.cs @@ -3,10 +3,10 @@ using System.Linq; using System.Reflection; using System.Text; -using MoonSharp.Hardwire.Generators; -using MoonSharp.Interpreter; +using WattleScript.Hardwire.Generators; +using WattleScript.Interpreter; -namespace MoonSharp.Hardwire +namespace WattleScript.Hardwire { public static class HardwireGeneratorRegistry { diff --git a/src/MoonSharp.Hardwire/ICodeGenerationLogger.cs b/src/WattleScript.Hardwire/ICodeGenerationLogger.cs similarity index 88% rename from src/MoonSharp.Hardwire/ICodeGenerationLogger.cs rename to src/WattleScript.Hardwire/ICodeGenerationLogger.cs index 31c85436..51accf9d 100644 --- a/src/MoonSharp.Hardwire/ICodeGenerationLogger.cs +++ b/src/WattleScript.Hardwire/ICodeGenerationLogger.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Hardwire +namespace WattleScript.Hardwire { public interface ICodeGenerationLogger { diff --git a/src/MoonSharp.Hardwire/IHardwireGenerator.cs b/src/WattleScript.Hardwire/IHardwireGenerator.cs similarity index 94% rename from src/MoonSharp.Hardwire/IHardwireGenerator.cs rename to src/WattleScript.Hardwire/IHardwireGenerator.cs index 4ba0d282..a52a381c 100644 --- a/src/MoonSharp.Hardwire/IHardwireGenerator.cs +++ b/src/WattleScript.Hardwire/IHardwireGenerator.cs @@ -2,9 +2,9 @@ using System.CodeDom; using System.Collections.Generic; using System.Linq; -using MoonSharp.Interpreter; +using WattleScript.Interpreter; -namespace MoonSharp.Hardwire +namespace WattleScript.Hardwire { /// /// Interface to be implemented by all hardwire code generators diff --git a/src/MoonSharp.HardwireGen/IdGen.cs b/src/WattleScript.Hardwire/IdGen.cs similarity index 97% rename from src/MoonSharp.HardwireGen/IdGen.cs rename to src/WattleScript.Hardwire/IdGen.cs index 823a0c5a..7233e6ab 100644 --- a/src/MoonSharp.HardwireGen/IdGen.cs +++ b/src/WattleScript.Hardwire/IdGen.cs @@ -5,7 +5,7 @@ using System.Text; using System.Security.Cryptography; -namespace MoonSharp.HardwireGen +namespace WattleScript.Hardwire { static class IdGen { diff --git a/src/MoonSharp.Hardwire/Languages/CSharpHardwireCodeGenerationLanguage.cs b/src/WattleScript.Hardwire/Languages/CSharpHardwireCodeGenerationLanguage.cs similarity index 97% rename from src/MoonSharp.Hardwire/Languages/CSharpHardwireCodeGenerationLanguage.cs rename to src/WattleScript.Hardwire/Languages/CSharpHardwireCodeGenerationLanguage.cs index 09a50ec8..5d727195 100644 --- a/src/MoonSharp.Hardwire/Languages/CSharpHardwireCodeGenerationLanguage.cs +++ b/src/WattleScript.Hardwire/Languages/CSharpHardwireCodeGenerationLanguage.cs @@ -5,7 +5,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Hardwire.Languages +namespace WattleScript.Hardwire.Languages { public class CSharpHardwireCodeGenerationLanguage : HardwireCodeGenerationLanguage { diff --git a/src/MoonSharp.Hardwire/Languages/HardwireCodeGenerationLanguage.cs b/src/WattleScript.Hardwire/Languages/HardwireCodeGenerationLanguage.cs similarity index 97% rename from src/MoonSharp.Hardwire/Languages/HardwireCodeGenerationLanguage.cs rename to src/WattleScript.Hardwire/Languages/HardwireCodeGenerationLanguage.cs index f335fa32..fd454450 100644 --- a/src/MoonSharp.Hardwire/Languages/HardwireCodeGenerationLanguage.cs +++ b/src/WattleScript.Hardwire/Languages/HardwireCodeGenerationLanguage.cs @@ -6,7 +6,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Hardwire.Languages +namespace WattleScript.Hardwire.Languages { public abstract class HardwireCodeGenerationLanguage { diff --git a/src/MoonSharp.Hardwire/Languages/VbHardwireCodeGenerationLanguage.cs b/src/WattleScript.Hardwire/Languages/VbHardwireCodeGenerationLanguage.cs similarity index 97% rename from src/MoonSharp.Hardwire/Languages/VbHardwireCodeGenerationLanguage.cs rename to src/WattleScript.Hardwire/Languages/VbHardwireCodeGenerationLanguage.cs index 84f68286..cf55acd3 100644 --- a/src/MoonSharp.Hardwire/Languages/VbHardwireCodeGenerationLanguage.cs +++ b/src/WattleScript.Hardwire/Languages/VbHardwireCodeGenerationLanguage.cs @@ -5,7 +5,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Hardwire.Languages +namespace WattleScript.Hardwire.Languages { public class VbHardwireCodeGenerationLanguage : HardwireCodeGenerationLanguage { diff --git a/src/WattleScript.Hardwire/Utils/GeneratorUtilities.cs b/src/WattleScript.Hardwire/Utils/GeneratorUtilities.cs new file mode 100644 index 00000000..6115549d --- /dev/null +++ b/src/WattleScript.Hardwire/Utils/GeneratorUtilities.cs @@ -0,0 +1,19 @@ +using System; +using System.CodeDom; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; + +namespace WattleScript.Hardwire.Utils +{ + public class GeneratorUtilities + { + + + + + } +} diff --git a/src/MoonSharp.Hardwire/Utils/HardwireParameterDescriptor.cs b/src/WattleScript.Hardwire/Utils/HardwireParameterDescriptor.cs similarity index 91% rename from src/MoonSharp.Hardwire/Utils/HardwireParameterDescriptor.cs rename to src/WattleScript.Hardwire/Utils/HardwireParameterDescriptor.cs index 5fd817e6..ca0ba38d 100644 --- a/src/MoonSharp.Hardwire/Utils/HardwireParameterDescriptor.cs +++ b/src/WattleScript.Hardwire/Utils/HardwireParameterDescriptor.cs @@ -3,11 +3,11 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; -namespace MoonSharp.Hardwire.Utils +namespace WattleScript.Hardwire.Utils { public class HardwireParameterDescriptor { diff --git a/src/MoonSharp.Hardwire/MoonSharp.Hardwire.csproj b/src/WattleScript.Hardwire/WattleScript.Hardwire.csproj similarity index 74% rename from src/MoonSharp.Hardwire/MoonSharp.Hardwire.csproj rename to src/WattleScript.Hardwire/WattleScript.Hardwire.csproj index e289e07c..ea41bfca 100644 --- a/src/MoonSharp.Hardwire/MoonSharp.Hardwire.csproj +++ b/src/WattleScript.Hardwire/WattleScript.Hardwire.csproj @@ -3,7 +3,7 @@ netstandard2.0 - + diff --git a/src/MoonSharp.HardwireGen/ExtraClassList.cs b/src/WattleScript.HardwireGen/ExtraClassList.cs similarity index 95% rename from src/MoonSharp.HardwireGen/ExtraClassList.cs rename to src/WattleScript.HardwireGen/ExtraClassList.cs index cf873dca..3390cc47 100644 --- a/src/MoonSharp.HardwireGen/ExtraClassList.cs +++ b/src/WattleScript.HardwireGen/ExtraClassList.cs @@ -2,9 +2,9 @@ using System.IO; using System.Xml.Serialization; -namespace MoonSharp.HardwireGen +namespace WattleScript.HardwireGen { - [XmlRoot("MoonSharp")] + [XmlRoot("WattleScript")] public class ExtraClassList { [XmlElement] diff --git a/src/MoonSharp.Hardwire/IdGen.cs b/src/WattleScript.HardwireGen/IdGen.cs similarity index 97% rename from src/MoonSharp.Hardwire/IdGen.cs rename to src/WattleScript.HardwireGen/IdGen.cs index 64d7e691..3b73cd5c 100644 --- a/src/MoonSharp.Hardwire/IdGen.cs +++ b/src/WattleScript.HardwireGen/IdGen.cs @@ -5,7 +5,7 @@ using System.Text; using System.Security.Cryptography; -namespace MoonSharp.Hardwire +namespace WattleScript.HardwireGen { static class IdGen { diff --git a/src/WattleScript.HardwireGen/SourceGenerator.ClassNames.cs b/src/WattleScript.HardwireGen/SourceGenerator.ClassNames.cs new file mode 100644 index 00000000..aeaffa8d --- /dev/null +++ b/src/WattleScript.HardwireGen/SourceGenerator.ClassNames.cs @@ -0,0 +1,23 @@ +namespace WattleScript.HardwireGen +{ + public partial class HardwireSourceGenerator + { + private const string CLS_USERDATA = + "WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors.HardwiredUserDataDescriptor"; + + private const string CLS_OVERLOAD = "WattleScript.Interpreter.Interop.OverloadedMethodMemberDescriptor"; + + private const string CLS_OVERLOAD_MEMBER = + "WattleScript.Interpreter.Interop.BasicDescriptors.IOverloadableMemberDescriptor"; + + private const string CLS_PROP_FIELD = + "WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors.HardwiredMemberDescriptor"; + + private const string CLS_METHOD = + "WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors.HardwiredMethodMemberDescriptor"; + + private const string CLS_PARAMETER = "WattleScript.Interpreter.Interop.BasicDescriptors.ParameterDescriptor"; + + + } +} \ No newline at end of file diff --git a/src/MoonSharp.HardwireGen/SourceGenerator.cs b/src/WattleScript.HardwireGen/SourceGenerator.cs similarity index 94% rename from src/MoonSharp.HardwireGen/SourceGenerator.cs rename to src/WattleScript.HardwireGen/SourceGenerator.cs index 8cf6a55e..6c0dbc12 100644 --- a/src/MoonSharp.HardwireGen/SourceGenerator.cs +++ b/src/WattleScript.HardwireGen/SourceGenerator.cs @@ -5,28 +5,28 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; -namespace MoonSharp.HardwireGen +namespace WattleScript.HardwireGen { [Generator] public partial class HardwireSourceGenerator : ISourceGenerator { private static DiagnosticDescriptor ByRefWarning = new("MS1001", "ByRef parameters can't be generated", - "Method '{0}' has ref/out parameters and won't be described, mark with MoonSharpHiddenAttribute.", - "MoonSharp.HardwireGen", DiagnosticSeverity.Warning, true); + "Method '{0}' has ref/out parameters and won't be described, mark with WattleScriptHiddenAttribute.", + "WattleScript.HardwireGen", DiagnosticSeverity.Warning, true); private static DiagnosticDescriptor NoFilesWarning = new("MS1002", "AdditionalFiles has no types listed", "File '{0}' has no additional types listed.", - "MoonSharp.HardwireGen", DiagnosticSeverity.Warning, true); + "WattleScript.HardwireGen", DiagnosticSeverity.Warning, true); private static DiagnosticDescriptor TypeResolveWarning = new("MS1003", "Type could not be resolved", "Type '{0}' from AdditionalFile '{1}' could not be resolved.", - "MoonSharp.HardwireGen", DiagnosticSeverity.Warning, true); + "WattleScript.HardwireGen", DiagnosticSeverity.Warning, true); private static DiagnosticDescriptor Timing = new("MS9999", "Generation duration", - "Hardwire generation took '{0}'ms", "MoonSharp.HardwireGen", DiagnosticSeverity.Info, true); + "Hardwire generation took '{0}'ms", "WattleScript.HardwireGen", DiagnosticSeverity.Info, true); public void Initialize(GeneratorInitializationContext context) { @@ -155,7 +155,7 @@ public void Execute(GeneratorExecutionContext context) var name = context.Compilation.Assembly.Name; if (string.IsNullOrEmpty(name)) name = IdGen.Create(context.Compilation.Assembly.NamespaceNames.FirstOrDefault() ?? - "_MoonSharp"); + "_WattleScript"); name = "LuaHardwire_" + Sanitize(name); foreach (var classDeclaration in receiver.Candidates) @@ -185,7 +185,7 @@ public void Execute(GeneratorExecutionContext context) writer.AppendLine("{").Indent(); foreach (var str in generatedClasses) { - writer.Append("MoonSharp.Interpreter.UserData.RegisterType(new ").Append(str).AppendLine("());"); + writer.Append("WattleScript.Interpreter.UserData.RegisterType(new ").Append(str).AppendLine("());"); } writer.UnIndent().AppendLine("}"); @@ -204,16 +204,16 @@ public void Execute(GeneratorExecutionContext context) static bool IsUserData(ITypeSymbol type) { return type.GetAttributes() - .Any(a => a.AttributeClass?.ToString() == "MoonSharp.Interpreter.MoonSharpUserDataAttribute"); + .Any(a => a.AttributeClass?.ToString() == "WattleScript.Interpreter.WattleScriptUserDataAttribute"); } static bool IsHidden(ISymbol symbol) { foreach (var attr in symbol.GetAttributes()) { - if (attr.AttributeClass?.ToString() == "MoonSharp.Interpreter.MoonSharpHiddenAttribute") + if (attr.AttributeClass?.ToString() == "WattleScript.Interpreter.WattleScriptHiddenAttribute") return true; - if (attr.AttributeClass?.ToString() == "MoonSharp.Interpreter.MoonSharpVisibleAttribute") + if (attr.AttributeClass?.ToString() == "WattleScript.Interpreter.WattleScriptVisibleAttribute") { if (attr.ConstructorArguments[0].Value is false) return true; @@ -438,14 +438,14 @@ void GenerateField(TabbedWriter builder, string typeName, TypeField f) if (f.Desc.Write) access += 2; //CanWrite builder.Indent().Append("base(typeof(").Append(f.Desc.Type.TypeName()).Append("),") .Append(f.Name.ToLiteral()).Append(",false,") - .Append("(MoonSharp.Interpreter.Interop.BasicDescriptors.MemberDescriptorAccess)") + .Append("(WattleScript.Interpreter.Interop.BasicDescriptors.MemberDescriptorAccess)") .Append(access.ToString()).AppendLine(")").UnIndent(); builder.AppendLine("{"); builder.AppendLine("}"); if (f.Desc.Read) { builder.AppendLine( - "protected override object GetValueImpl(MoonSharp.Interpreter.Script script, object obj) {") + "protected override object GetValueImpl(WattleScript.Interpreter.Script script, object obj) {") .Indent(); builder.Append("var self = (").Append(typeName).AppendLine(")obj;"); builder.Append("return (object)self.").Append(f.Name).AppendLine(";"); @@ -454,7 +454,7 @@ void GenerateField(TabbedWriter builder, string typeName, TypeField f) if (f.Desc.Write) { builder.AppendLine( - "protected override void SetValueImpl(MoonSharp.Interpreter.Script script, object obj, object value) {") + "protected override void SetValueImpl(WattleScript.Interpreter.Script script, object obj, object value) {") .Indent(); builder.Append("var self = (").Append(typeName).AppendLine(")obj;"); builder.Append("self.").Append(f.Name).Append(" = (").Append(f.Desc.Type.TypeName()).AppendLine(")value;"); @@ -498,7 +498,7 @@ void GenerateMethod(TabbedWriter builder, string typeName, TypeMethod m) builder.UnIndent().AppendLine("}"); //invoke builder.AppendLine( - "protected override object Invoke(MoonSharp.Interpreter.Script script, object obj, object[] pars, int argscount)"); + "protected override object Invoke(WattleScript.Interpreter.Script script, object obj, object[] pars, int argscount)"); builder.AppendLine("{").Indent(); if (!m.Constructor) builder.Append("var self = (").Append(typeName).AppendLine(")obj;"); @@ -624,7 +624,7 @@ public void OnVisitSyntaxNode(SyntaxNode syntaxNode) var name = ExtractName(attribute.Name); - if (name != "MoonSharpUserData" && name != "MoonSharpUserDataAttribute") + if (name != "WattleScriptUserData" && name != "WattleScriptUserDataAttribute") return; // "attribute.Parent" is "AttributeListSyntax" diff --git a/src/MoonSharp.HardwireGen/StringUtils.cs b/src/WattleScript.HardwireGen/StringUtils.cs similarity index 90% rename from src/MoonSharp.HardwireGen/StringUtils.cs rename to src/WattleScript.HardwireGen/StringUtils.cs index 95316619..91d5da33 100644 --- a/src/MoonSharp.HardwireGen/StringUtils.cs +++ b/src/WattleScript.HardwireGen/StringUtils.cs @@ -1,7 +1,7 @@ using System; using Microsoft.CodeAnalysis.CSharp; -namespace MoonSharp.HardwireGen +namespace WattleScript.HardwireGen { public static class StringUtils { diff --git a/src/MoonSharp.HardwireGen/SymbolUtils.cs b/src/WattleScript.HardwireGen/SymbolUtils.cs similarity index 97% rename from src/MoonSharp.HardwireGen/SymbolUtils.cs rename to src/WattleScript.HardwireGen/SymbolUtils.cs index 2e9cfa72..8c8f96cb 100644 --- a/src/MoonSharp.HardwireGen/SymbolUtils.cs +++ b/src/WattleScript.HardwireGen/SymbolUtils.cs @@ -3,7 +3,7 @@ using System.Linq; using Microsoft.CodeAnalysis; -namespace MoonSharp.HardwireGen +namespace WattleScript.HardwireGen { public static class SymbolUtils { diff --git a/src/MoonSharp.HardwireGen/TabbedWriter.cs b/src/WattleScript.HardwireGen/TabbedWriter.cs similarity index 97% rename from src/MoonSharp.HardwireGen/TabbedWriter.cs rename to src/WattleScript.HardwireGen/TabbedWriter.cs index 1e09f7b0..2d7d3106 100644 --- a/src/MoonSharp.HardwireGen/TabbedWriter.cs +++ b/src/WattleScript.HardwireGen/TabbedWriter.cs @@ -1,6 +1,6 @@ using System; using System.Text; -namespace MoonSharp.HardwireGen +namespace WattleScript.HardwireGen { public class TabbedWriter { diff --git a/src/MoonSharp.HardwireGen/TypeGenQueue.cs b/src/WattleScript.HardwireGen/TypeGenQueue.cs similarity index 94% rename from src/MoonSharp.HardwireGen/TypeGenQueue.cs rename to src/WattleScript.HardwireGen/TypeGenQueue.cs index 2e67f127..1056393c 100644 --- a/src/MoonSharp.HardwireGen/TypeGenQueue.cs +++ b/src/WattleScript.HardwireGen/TypeGenQueue.cs @@ -1,7 +1,7 @@ using System.Collections.Generic; using Microsoft.CodeAnalysis; -namespace MoonSharp.HardwireGen +namespace WattleScript.HardwireGen { public class TypeGenQueue { diff --git a/src/MoonSharp.HardwireGen/MoonSharp.HardwireGen.csproj b/src/WattleScript.HardwireGen/WattleScript.HardwireGen.csproj similarity index 100% rename from src/MoonSharp.HardwireGen/MoonSharp.HardwireGen.csproj rename to src/WattleScript.HardwireGen/WattleScript.HardwireGen.csproj diff --git a/src/MoonSharp.Interpreter/AsyncExtensions.cs b/src/WattleScript.Interpreter/AsyncExtensions.cs similarity index 94% rename from src/MoonSharp.Interpreter/AsyncExtensions.cs rename to src/WattleScript.Interpreter/AsyncExtensions.cs index eb0055c5..a8357d12 100755 --- a/src/MoonSharp.Interpreter/AsyncExtensions.cs +++ b/src/WattleScript.Interpreter/AsyncExtensions.cs @@ -6,9 +6,9 @@ using System.Text; using System.Threading; using System.Threading.Tasks; -using MoonSharp.Interpreter.REPL; +using WattleScript.Interpreter.REPL; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// This class contains extension methods providing async wrappers of many methods. @@ -72,7 +72,7 @@ public static Task CallAsync(this Closure function, params DynValue[] } /// - /// Asynchronously loads and executes a string containing a Lua/MoonSharp script. + /// Asynchronously loads and executes a string containing a Lua/WattleScript script. /// /// This method is supported only on .NET 4.x and .NET 4.x PCL targets. /// @@ -90,7 +90,7 @@ public static Task DoStringAsync(this Script script, string code, Tabl /// - /// Asynchronously loads and executes a stream containing a Lua/MoonSharp script. + /// Asynchronously loads and executes a stream containing a Lua/WattleScript script. /// /// This method is supported only on .NET 4.x and .NET 4.x PCL targets. /// @@ -108,7 +108,7 @@ public static Task DoStreamAsync(this Script script, Stream stream, Ta /// - /// Asynchronously loads and executes a file containing a Lua/MoonSharp script. + /// Asynchronously loads and executes a file containing a Lua/WattleScript script. /// /// This method is supported only on .NET 4.x and .NET 4.x PCL targets. /// @@ -125,7 +125,7 @@ public static Task DoFileAsync(this Script script, string filename, Ta } /// - /// Asynchronously loads a string containing a Lua/MoonSharp function. + /// Asynchronously loads a string containing a Lua/WattleScript function. /// /// This method is supported only on .NET 4.x and .NET 4.x PCL targets. /// @@ -144,7 +144,7 @@ public static Task LoadFunctionAsync(this Script script, string code, /// - /// Asynchronously loads a string containing a Lua/MoonSharp script. + /// Asynchronously loads a string containing a Lua/WattleScript script. /// /// This method is supported only on .NET 4.x and .NET 4.x PCL targets. /// @@ -163,7 +163,7 @@ public static Task LoadStringAsync(this Script script, string code, Ta /// - /// Asynchronously loads a Lua/MoonSharp script from a System.IO.Stream. NOTE: This will *NOT* close the stream! + /// Asynchronously loads a Lua/WattleScript script from a System.IO.Stream. NOTE: This will *NOT* close the stream! /// /// This method is supported only on .NET 4.x and .NET 4.x PCL targets. /// @@ -201,7 +201,7 @@ public static Task DumpAsync(this Script script, DynValue function, Stream strea /// - /// Asynchronously loads a string containing a Lua/MoonSharp script. + /// Asynchronously loads a string containing a Lua/WattleScript script. /// This method is supported only on .NET 4.x and .NET 4.x PCL targets. /// /// The script. @@ -223,7 +223,7 @@ public static Task LoadFileAsync(this Script script, string filename, /// This method is supported only on .NET 4.x and .NET 4.x PCL targets. /// /// The script. - /// The Lua/MoonSharp function to be called + /// The Lua/WattleScript function to be called /// /// The return value(s) of the function call. /// @@ -239,7 +239,7 @@ public static Task CallAsync(this Script script, DynValue function) /// This method is supported only on .NET 4.x and .NET 4.x PCL targets. /// /// The script. - /// The Lua/MoonSharp function to be called + /// The Lua/WattleScript function to be called /// The arguments to pass to the function. /// /// The return value(s) of the function call. @@ -257,7 +257,7 @@ public static Task CallAsync(this Script script, DynValue function, pa /// This method is supported only on .NET 4.x and .NET 4.x PCL targets. /// /// The script. - /// The Lua/MoonSharp function to be called + /// The Lua/WattleScript function to be called /// The arguments to pass to the function. /// /// The return value(s) of the function call. @@ -275,7 +275,7 @@ public static Task CallAsync(this Script script, DynValue function, pa /// This method is supported only on .NET 4.x and .NET 4.x PCL targets. ///

/// The script. - /// The Lua/MoonSharp function to be called + /// The Lua/WattleScript function to be called /// /// Thrown if function is not of DataType.Function public static Task CallAsync(this Script script, object function) @@ -290,7 +290,7 @@ public static Task CallAsync(this Script script, object function) /// This method is supported only on .NET 4.x and .NET 4.x PCL targets. /// /// The script. - /// The Lua/MoonSharp function to be called + /// The Lua/WattleScript function to be called /// The arguments to pass to the function. /// /// Thrown if function is not of DataType.Function diff --git a/src/MoonSharp.Interpreter/CoreLib/BasicModule.cs b/src/WattleScript.Interpreter/CoreLib/BasicModule.cs similarity index 96% rename from src/MoonSharp.Interpreter/CoreLib/BasicModule.cs rename to src/WattleScript.Interpreter/CoreLib/BasicModule.cs index a4796055..242e299f 100755 --- a/src/MoonSharp.Interpreter/CoreLib/BasicModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/BasicModule.cs @@ -5,21 +5,21 @@ using System.Collections.Generic; using System.Globalization; using System.Text; -using MoonSharp.Interpreter.Debugging; +using WattleScript.Interpreter.Debugging; -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// - /// Class implementing basic Lua functions (print, type, tostring, etc) as a MoonSharp module. + /// Class implementing basic Lua functions (print, type, tostring, etc) as a WattleScript module. /// - [MoonSharpModule] + [WattleScriptModule] public class BasicModule { //type (v) //---------------------------------------------------------------------------------------------------------------- //Returns the type of its only argument, coded as a string. The possible results of this function are "nil" //(a string, not the value nil), "number", "string", "boolean", "table", "function", "thread", and "userdata". - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue type(ScriptExecutionContext executionContext, CallbackArguments args) { if (args.Count < 1) throw ScriptRuntimeException.BadArgumentValueExpected(0, "type"); @@ -34,7 +34,7 @@ public static DynValue type(ScriptExecutionContext executionContext, CallbackArg //---------------------------------------------------------------------------------------------------------------- //Issues an error when the value of its argument v is false (i.e., nil or false); //otherwise, returns all its arguments. message is an error message; when absent, it defaults to "assertion failed!" - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue assert(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue v = args[0]; @@ -54,7 +54,7 @@ public static DynValue assert(ScriptExecutionContext executionContext, CallbackA // collectgarbage ([opt [, arg]]) // ---------------------------------------------------------------------------------------------------------------- // This function is a stub. Lua scripts cannot force a .NET GC - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue collectgarbage(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue opt = args[0]; @@ -77,7 +77,7 @@ public static DynValue collectgarbage(ScriptExecutionContext executionContext, C // With level 1 (the default), the error position is where the error function was called. // Level 2 points the error to where the function that called error was called; and so on. // Passing a level 0 avoids the addition of error position information to the message. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue error(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue message = args.AsType(0, "error", DataType.String, false); @@ -118,7 +118,7 @@ public static DynValue error(ScriptExecutionContext executionContext, CallbackAr // // If the metatable of v has a "__tostring" field, then tostring calls the corresponding value with v as argument, // and uses the result of the call as its result. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue tostring(ScriptExecutionContext executionContext, CallbackArguments args) { if (args.Count < 1) throw ScriptRuntimeException.BadArgumentValueExpected(0, "tostring"); @@ -153,7 +153,7 @@ private static DynValue __tostring_continuation(ScriptExecutionContext execution // If index is a number, returns all arguments after argument number index; a negative number indexes from // the end (-1 is the last argument). Otherwise, index must be the string "#", and select returns the total // number of extra arguments it received. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue select(ScriptExecutionContext executionContext, CallbackArguments args) { if (args[0].Type == DataType.String && args[0].String == "#") @@ -209,7 +209,7 @@ public static DynValue select(ScriptExecutionContext executionContext, CallbackA // The base may be any integer between 2 and 36, inclusive. In bases above 10, the letter 'A' (in either // upper or lower case) represents 10, 'B' represents 11, and so forth, with 'Z' representing 35. If the // string e is not a valid numeral in the given base, the function returns nil. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue tonumber(ScriptExecutionContext executionContext, CallbackArguments args) { if (args.Count < 1) throw ScriptRuntimeException.BadArgumentValueExpected(0, "tonumber"); @@ -277,7 +277,7 @@ public static DynValue tonumber(ScriptExecutionContext executionContext, Callbac } } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue print(ScriptExecutionContext executionContext, CallbackArguments args) { StringBuilder sb = new StringBuilder(); diff --git a/src/MoonSharp.Interpreter/CoreLib/Bit32Module.cs b/src/WattleScript.Interpreter/CoreLib/Bit32Module.cs similarity index 93% rename from src/MoonSharp.Interpreter/CoreLib/Bit32Module.cs rename to src/WattleScript.Interpreter/CoreLib/Bit32Module.cs index bb877efc..1b1786aa 100755 --- a/src/MoonSharp.Interpreter/CoreLib/Bit32Module.cs +++ b/src/WattleScript.Interpreter/CoreLib/Bit32Module.cs @@ -3,12 +3,12 @@ using System; -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing bit32 Lua functions /// - [MoonSharpModule(Namespace = "bit32")] + [WattleScriptModule(Namespace = "bit32")] public class Bit32Module { static readonly uint[] MASKS = new uint[] { @@ -60,7 +60,7 @@ public static uint Bitwise(string funcName, CallbackArguments args, Func x & y)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue btest(ScriptExecutionContext executionContext, CallbackArguments args) { return DynValue.NewBoolean(0 != Bitwise("btest", args, (x, y) => x & y)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue bor(ScriptExecutionContext executionContext, CallbackArguments args) { return DynValue.NewNumber(Bitwise("bor", args, (x, y) => x | y)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue bnot(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue v_v = args.AsType(0, "bnot", DataType.Number); @@ -199,13 +199,13 @@ public static DynValue bnot(ScriptExecutionContext executionContext, CallbackArg return DynValue.NewNumber(~v); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue bxor(ScriptExecutionContext executionContext, CallbackArguments args) { return DynValue.NewNumber(Bitwise("bxor", args, (x, y) => x ^ y)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue lrotate(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue v_v = args.AsType(0, "lrotate", DataType.Number); @@ -223,7 +223,7 @@ public static DynValue lrotate(ScriptExecutionContext executionContext, Callback return DynValue.NewNumber(v); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue rrotate(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue v_v = args.AsType(0, "rrotate", DataType.Number); diff --git a/src/MoonSharp.Interpreter/CoreLib/CoroutineModule.cs b/src/WattleScript.Interpreter/CoreLib/CoroutineModule.cs similarity index 92% rename from src/MoonSharp.Interpreter/CoreLib/CoroutineModule.cs rename to src/WattleScript.Interpreter/CoreLib/CoroutineModule.cs index d405a88e..6bcd1ec3 100644 --- a/src/MoonSharp.Interpreter/CoreLib/CoroutineModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/CoroutineModule.cs @@ -3,15 +3,15 @@ using System.Collections.Generic; -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing coroutine Lua functions /// - [MoonSharpModule(Namespace = "coroutine")] + [WattleScriptModule(Namespace = "coroutine")] public class CoroutineModule { - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue create(ScriptExecutionContext executionContext, CallbackArguments args) { if (args[0].Type != DataType.Function && args[0].Type != DataType.ClrFunction) @@ -20,7 +20,7 @@ public static DynValue create(ScriptExecutionContext executionContext, CallbackA return executionContext.GetScript().CreateCoroutine(args[0]); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue wrap(ScriptExecutionContext executionContext, CallbackArguments args) { if (args[0].Type != DataType.Function && args[0].Type != DataType.ClrFunction) @@ -38,7 +38,7 @@ public static DynValue __wrap_wrapper(ScriptExecutionContext executionContext, C return handle.Coroutine.Resume(args.GetArray()); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue resume(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue handle = args.AsType(0, "resume", DataType.Thread); @@ -81,7 +81,7 @@ public static DynValue resume(ScriptExecutionContext executionContext, CallbackA } } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue yield(ScriptExecutionContext executionContext, CallbackArguments args) { return DynValue.NewYieldReq(args.GetArray()); @@ -89,14 +89,14 @@ public static DynValue yield(ScriptExecutionContext executionContext, CallbackAr - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue running(ScriptExecutionContext executionContext, CallbackArguments args) { Coroutine C = executionContext.GetCallingCoroutine(); return DynValue.NewTuple(DynValue.NewCoroutine(C), DynValue.NewBoolean(C.State == CoroutineState.Main)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue status(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue handle = args.AsType(0, "status", DataType.Thread); diff --git a/src/MoonSharp.Interpreter/CoreLib/DebugModule.cs b/src/WattleScript.Interpreter/CoreLib/DebugModule.cs similarity index 94% rename from src/MoonSharp.Interpreter/CoreLib/DebugModule.cs rename to src/WattleScript.Interpreter/CoreLib/DebugModule.cs index 6343192c..1096c58e 100644 --- a/src/MoonSharp.Interpreter/CoreLib/DebugModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/DebugModule.cs @@ -3,18 +3,18 @@ using System; using System.Text; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.REPL; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.REPL; -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing debug Lua functions. Support for the debug module is partial. /// - [MoonSharpModule(Namespace = "debug")] + [WattleScriptModule(Namespace = "debug")] public class DebugModule { - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue debug(ScriptExecutionContext executionContext, CallbackArguments args) { Script script = executionContext.GetScript(); @@ -50,7 +50,7 @@ public static DynValue debug(ScriptExecutionContext executionContext, CallbackAr } } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue getuservalue(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue v = args[0]; @@ -61,7 +61,7 @@ public static DynValue getuservalue(ScriptExecutionContext executionContext, Cal return v.UserData.UserValue; } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue setuservalue(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue v = args.AsType(0, "setuservalue", DataType.UserData, false); @@ -70,13 +70,13 @@ public static DynValue setuservalue(ScriptExecutionContext executionContext, Cal return v.UserData.UserValue = t; } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue getregistry(ScriptExecutionContext executionContext, CallbackArguments args) { return DynValue.NewTable(executionContext.GetScript().Registry); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue getmetatable(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue v = args[0]; @@ -90,7 +90,7 @@ public static DynValue getmetatable(ScriptExecutionContext executionContext, Cal return DynValue.Nil; } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue setmetatable(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue v = args[0]; @@ -108,7 +108,7 @@ public static DynValue setmetatable(ScriptExecutionContext executionContext, Cal return v; } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue getupvalue(ScriptExecutionContext executionContext, CallbackArguments args) { var index = (int)args.AsType(1, "getupvalue", DataType.Number, false).Number - 1; @@ -129,7 +129,7 @@ public static DynValue getupvalue(ScriptExecutionContext executionContext, Callb } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue upvalueid(ScriptExecutionContext executionContext, CallbackArguments args) { var index = (int)args.AsType(1, "getupvalue", DataType.Number, false).Number - 1; @@ -148,7 +148,7 @@ public static DynValue upvalueid(ScriptExecutionContext executionContext, Callba } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue setupvalue(ScriptExecutionContext executionContext, CallbackArguments args) { var index = (int)args.AsType(1, "setupvalue", DataType.Number, false).Number - 1; @@ -169,7 +169,7 @@ public static DynValue setupvalue(ScriptExecutionContext executionContext, Callb } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue upvaluejoin(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue f1 = args.AsType(0, "upvaluejoin", DataType.Function, false); @@ -192,7 +192,7 @@ public static DynValue upvaluejoin(ScriptExecutionContext executionContext, Call } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue traceback(ScriptExecutionContext executionContext, CallbackArguments args) { StringBuilder sb = new StringBuilder(); @@ -247,7 +247,7 @@ public static DynValue traceback(ScriptExecutionContext executionContext, Callba return DynValue.NewString(sb); } - //[MoonSharpModuleMethod] + //[WattleScriptModuleMethod] //public static DynValue getlocal(ScriptExecutionContext executionContext, CallbackArguments args) //{ // Coroutine c; @@ -297,7 +297,7 @@ public static DynValue traceback(ScriptExecutionContext executionContext, Callba //} - //[MoonSharpMethod] + //[WattleScriptMethod] //public static DynValue getinfo(ScriptExecutionContext executionContext, CallbackArguments args) //{ // Coroutine cor = executionContext.GetCallingCoroutine(); diff --git a/src/MoonSharp.Interpreter/CoreLib/DynamicModule.cs b/src/WattleScript.Interpreter/CoreLib/DynamicModule.cs similarity index 86% rename from src/MoonSharp.Interpreter/CoreLib/DynamicModule.cs rename to src/WattleScript.Interpreter/CoreLib/DynamicModule.cs index a7e40ef6..1db17abd 100644 --- a/src/MoonSharp.Interpreter/CoreLib/DynamicModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/DynamicModule.cs @@ -2,12 +2,12 @@ #pragma warning disable 1591 -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// - /// Class implementing dynamic expression evaluations at runtime (a MoonSharp addition). + /// Class implementing dynamic expression evaluations at runtime (a WattleScript addition). /// - [MoonSharpModule(Namespace = "dynamic")] + [WattleScriptModule(Namespace = "dynamic")] public class DynamicModule { private class DynamicExprWrapper @@ -15,12 +15,12 @@ private class DynamicExprWrapper public DynamicExpression Expr; } - public static void MoonSharpInit(Table globalTable, Table stringTable) + public static void WattleScriptInit(Table globalTable, Table stringTable) { UserData.RegisterType(InteropAccessMode.HideMembers); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue eval(ScriptExecutionContext executionContext, CallbackArguments args) { try @@ -50,7 +50,7 @@ public static DynValue eval(ScriptExecutionContext executionContext, CallbackArg } } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue prepare(ScriptExecutionContext executionContext, CallbackArguments args) { try diff --git a/src/MoonSharp.Interpreter/CoreLib/ErrorHandlingModule.cs b/src/WattleScript.Interpreter/CoreLib/ErrorHandlingModule.cs similarity index 96% rename from src/MoonSharp.Interpreter/CoreLib/ErrorHandlingModule.cs rename to src/WattleScript.Interpreter/CoreLib/ErrorHandlingModule.cs index ef9122ed..8cc1646f 100644 --- a/src/MoonSharp.Interpreter/CoreLib/ErrorHandlingModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/ErrorHandlingModule.cs @@ -3,15 +3,15 @@ using System.Collections.Generic; -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing error handling Lua functions (pcall and xpcall) /// - [MoonSharpModule] + [WattleScriptModule] public class ErrorHandlingModule { - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue pcall(ScriptExecutionContext executionContext, CallbackArguments args) { return SetErrorHandlerStrategy("pcall", executionContext, args, DynValue.Nil); @@ -104,7 +104,7 @@ public static DynValue pcall_onerror(ScriptExecutionContext executionContext, Ca } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue xpcall(ScriptExecutionContext executionContext, CallbackArguments args) { List a = new List(); diff --git a/src/MoonSharp.Interpreter/CoreLib/IO/BinaryEncoding.cs b/src/WattleScript.Interpreter/CoreLib/IO/BinaryEncoding.cs similarity index 95% rename from src/MoonSharp.Interpreter/CoreLib/IO/BinaryEncoding.cs rename to src/WattleScript.Interpreter/CoreLib/IO/BinaryEncoding.cs index 9f4e84d2..b75f5e03 100644 --- a/src/MoonSharp.Interpreter/CoreLib/IO/BinaryEncoding.cs +++ b/src/WattleScript.Interpreter/CoreLib/IO/BinaryEncoding.cs @@ -1,6 +1,6 @@ using System.Text; -namespace MoonSharp.Interpreter.CoreLib.IO +namespace WattleScript.Interpreter.CoreLib.IO { class BinaryEncoding : Encoding { diff --git a/src/MoonSharp.Interpreter/CoreLib/IO/FileUserData.cs b/src/WattleScript.Interpreter/CoreLib/IO/FileUserData.cs similarity index 93% rename from src/MoonSharp.Interpreter/CoreLib/IO/FileUserData.cs rename to src/WattleScript.Interpreter/CoreLib/IO/FileUserData.cs index 0f466389..2a203076 100644 --- a/src/MoonSharp.Interpreter/CoreLib/IO/FileUserData.cs +++ b/src/WattleScript.Interpreter/CoreLib/IO/FileUserData.cs @@ -1,7 +1,7 @@ using System.IO; using System.Text; -namespace MoonSharp.Interpreter.CoreLib.IO +namespace WattleScript.Interpreter.CoreLib.IO { /// /// Abstract class implementing a file Lua userdata. Methods are meant to be called by Lua code. diff --git a/src/MoonSharp.Interpreter/CoreLib/IO/FileUserDataBase.cs b/src/WattleScript.Interpreter/CoreLib/IO/FileUserDataBase.cs similarity index 99% rename from src/MoonSharp.Interpreter/CoreLib/IO/FileUserDataBase.cs rename to src/WattleScript.Interpreter/CoreLib/IO/FileUserDataBase.cs index 418e825e..fc143e23 100755 --- a/src/MoonSharp.Interpreter/CoreLib/IO/FileUserDataBase.cs +++ b/src/WattleScript.Interpreter/CoreLib/IO/FileUserDataBase.cs @@ -2,7 +2,7 @@ using System.Collections.Generic; using System.Linq; -namespace MoonSharp.Interpreter.CoreLib.IO +namespace WattleScript.Interpreter.CoreLib.IO { /// /// Abstract class implementing a file Lua userdata. Methods are meant to be called by Lua code. diff --git a/src/MoonSharp.Interpreter/CoreLib/IO/StandardIOFileUserDataBase.cs b/src/WattleScript.Interpreter/CoreLib/IO/StandardIOFileUserDataBase.cs similarity index 94% rename from src/MoonSharp.Interpreter/CoreLib/IO/StandardIOFileUserDataBase.cs rename to src/WattleScript.Interpreter/CoreLib/IO/StandardIOFileUserDataBase.cs index af830986..76962e83 100644 --- a/src/MoonSharp.Interpreter/CoreLib/IO/StandardIOFileUserDataBase.cs +++ b/src/WattleScript.Interpreter/CoreLib/IO/StandardIOFileUserDataBase.cs @@ -1,6 +1,6 @@ using System.IO; -namespace MoonSharp.Interpreter.CoreLib.IO +namespace WattleScript.Interpreter.CoreLib.IO { /// /// Abstract class implementing an unclosable file Lua userdata. Methods are meant to be called by Lua code. diff --git a/src/MoonSharp.Interpreter/CoreLib/IO/StreamFileUserDataBase.cs b/src/WattleScript.Interpreter/CoreLib/IO/StreamFileUserDataBase.cs similarity index 98% rename from src/MoonSharp.Interpreter/CoreLib/IO/StreamFileUserDataBase.cs rename to src/WattleScript.Interpreter/CoreLib/IO/StreamFileUserDataBase.cs index 706e8bfd..98682983 100644 --- a/src/MoonSharp.Interpreter/CoreLib/IO/StreamFileUserDataBase.cs +++ b/src/WattleScript.Interpreter/CoreLib/IO/StreamFileUserDataBase.cs @@ -1,6 +1,6 @@ using System.IO; -namespace MoonSharp.Interpreter.CoreLib.IO +namespace WattleScript.Interpreter.CoreLib.IO { /// /// Abstract class implementing a file Lua userdata. Methods are meant to be called by Lua code. diff --git a/src/MoonSharp.Interpreter/CoreLib/IoModule.cs b/src/WattleScript.Interpreter/CoreLib/IoModule.cs similarity index 94% rename from src/MoonSharp.Interpreter/CoreLib/IoModule.cs rename to src/WattleScript.Interpreter/CoreLib/IoModule.cs index c5b554e2..5d67ac38 100755 --- a/src/MoonSharp.Interpreter/CoreLib/IoModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/IoModule.cs @@ -6,18 +6,18 @@ using System.IO; using System.Linq; using System.Text; -using MoonSharp.Interpreter.CoreLib.IO; -using MoonSharp.Interpreter.Platforms; +using WattleScript.Interpreter.CoreLib.IO; +using WattleScript.Interpreter.Platforms; -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing io Lua functions. Proper support requires a compatible IPlatformAccessor /// - [MoonSharpModule(Namespace = "io")] + [WattleScriptModule(Namespace = "io")] public class IoModule { - public static void MoonSharpInit(Table globalTable, Table ioTable) + public static void WattleScriptInit(Table globalTable, Table ioTable) { UserData.RegisterType(InteropAccessMode.Default, "file"); @@ -105,14 +105,14 @@ public static void SetDefaultFile(Script script, StandardFileType file, Stream s } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue close(ScriptExecutionContext executionContext, CallbackArguments args) { FileUserDataBase outp = args.AsUserData(0, "close", true) ?? GetDefaultFile(executionContext, StandardFileType.StdOut); return outp.close(executionContext, args); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue flush(ScriptExecutionContext executionContext, CallbackArguments args) { FileUserDataBase outp = args.AsUserData(0, "close", true) ?? GetDefaultFile(executionContext, StandardFileType.StdOut); @@ -121,13 +121,13 @@ public static DynValue flush(ScriptExecutionContext executionContext, CallbackAr } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue input(ScriptExecutionContext executionContext, CallbackArguments args) { return HandleDefaultStreamSetter(executionContext, args, StandardFileType.StdIn); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue output(ScriptExecutionContext executionContext, CallbackArguments args) { return HandleDefaultStreamSetter(executionContext, args, StandardFileType.StdOut); @@ -163,7 +163,7 @@ private static Encoding GetUTF8Encoding() return new System.Text.UTF8Encoding(false); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue lines(ScriptExecutionContext executionContext, CallbackArguments args) { string filename = args.AsType(0, "lines", DataType.String, false).String; @@ -194,7 +194,7 @@ public static DynValue lines(ScriptExecutionContext executionContext, CallbackAr } } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue open(ScriptExecutionContext executionContext, CallbackArguments args) { string filename = args.AsType(0, "open", DataType.String, false).String; @@ -259,7 +259,7 @@ public static string IoExceptionToLuaMessage(Exception ex, string filename) return ex.Message; } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue type(ScriptExecutionContext executionContext, CallbackArguments args) { if (args[0].Type != DataType.UserData) @@ -275,21 +275,21 @@ public static DynValue type(ScriptExecutionContext executionContext, CallbackArg return DynValue.NewString("closed file"); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue read(ScriptExecutionContext executionContext, CallbackArguments args) { FileUserDataBase file = GetDefaultFile(executionContext, StandardFileType.StdIn); return file.read(executionContext, args); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue write(ScriptExecutionContext executionContext, CallbackArguments args) { FileUserDataBase file = GetDefaultFile(executionContext, StandardFileType.StdOut); return file.write(executionContext, args); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue tmpfile(ScriptExecutionContext executionContext, CallbackArguments args) { string tmpfilename = Script.GlobalOptions.Platform.IO_OS_GetTempFilename(); diff --git a/src/MoonSharp.Interpreter/CoreLib/JsonModule.cs b/src/WattleScript.Interpreter/CoreLib/JsonModule.cs similarity index 83% rename from src/MoonSharp.Interpreter/CoreLib/JsonModule.cs rename to src/WattleScript.Interpreter/CoreLib/JsonModule.cs index d4f8c0f1..5315ac8a 100755 --- a/src/MoonSharp.Interpreter/CoreLib/JsonModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/JsonModule.cs @@ -2,14 +2,14 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Serialization.Json; +using WattleScript.Interpreter.Serialization.Json; -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { - [MoonSharpModule(Namespace = "json")] + [WattleScriptModule(Namespace = "json")] public class JsonModule { - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue parse(ScriptExecutionContext executionContext, CallbackArguments args) { try @@ -24,7 +24,7 @@ public static DynValue parse(ScriptExecutionContext executionContext, CallbackAr } } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue serialize(ScriptExecutionContext executionContext, CallbackArguments args) { try @@ -39,14 +39,14 @@ public static DynValue serialize(ScriptExecutionContext executionContext, Callba } } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue isnull(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue vs = args[0]; return DynValue.NewBoolean((JsonNull.IsJsonNull(vs)) || (vs.IsNil())); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue @null(ScriptExecutionContext executionContext, CallbackArguments args) { return JsonNull.Create(); diff --git a/src/MoonSharp.Interpreter/CoreLib/LoadModule.cs b/src/WattleScript.Interpreter/CoreLib/LoadModule.cs similarity index 95% rename from src/MoonSharp.Interpreter/CoreLib/LoadModule.cs rename to src/WattleScript.Interpreter/CoreLib/LoadModule.cs index 017b5111..3950905b 100755 --- a/src/MoonSharp.Interpreter/CoreLib/LoadModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/LoadModule.cs @@ -2,15 +2,15 @@ #pragma warning disable 1591 -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing loading Lua functions like 'require', 'load', etc. /// - [MoonSharpModule] + [WattleScriptModule] public class LoadModule { - public static void MoonSharpInit(Table globalTable, Table ioTable) + public static void WattleScriptInit(Table globalTable, Table ioTable) { DynValue package = globalTable.Get("package"); @@ -45,7 +45,7 @@ public static void MoonSharpInit(Table globalTable, Table ioTable) // or to "=(load)" otherwise. // // The string mode is ignored, and assumed to be "t"; - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue load(ScriptExecutionContext executionContext, CallbackArguments args) { return load_impl(executionContext, args, null); @@ -55,7 +55,7 @@ public static DynValue load(ScriptExecutionContext executionContext, CallbackArg // ---------------------------------------------------------------- // Same as load, except that "env" defaults to the current environment of the function // calling load, instead of the actual global environment. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue loadsafe(ScriptExecutionContext executionContext, CallbackArguments args) { return load_impl(executionContext, args, GetSafeDefaultEnv(executionContext)); @@ -110,7 +110,7 @@ public static DynValue load_impl(ScriptExecutionContext executionContext, Callba // ---------------------------------------------------------------- // Similar to load, but gets the chunk from file filename or from the standard input, // if no file name is given. INCOMPAT: stdin not supported, mode ignored - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue loadfile(ScriptExecutionContext executionContext, CallbackArguments args) { return loadfile_impl(executionContext, args, null); @@ -120,7 +120,7 @@ public static DynValue loadfile(ScriptExecutionContext executionContext, Callbac // ---------------------------------------------------------------- // Same as loadfile, except that "env" defaults to the current environment of the function // calling load, instead of the actual global environment. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue loadfilesafe(ScriptExecutionContext executionContext, CallbackArguments args) { return loadfile_impl(executionContext, args, GetSafeDefaultEnv(executionContext)); @@ -162,7 +162,7 @@ private static Table GetSafeDefaultEnv(ScriptExecutionContext executionContext) //Opens the named file and executes its contents as a Lua chunk. When called without arguments, //dofile executes the contents of the standard input (stdin). Returns all values returned by the chunk. //In case of errors, dofile propagates the error to its caller (that is, dofile does not run in protected mode). - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue dofile(ScriptExecutionContext executionContext, CallbackArguments args) { try @@ -201,7 +201,7 @@ public static DynValue dofile(ScriptExecutionContext executionContext, CallbackA // //If there is any error loading or running the module, or if it cannot find any loader for the module, then require //signals an error. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue __require_clr_impl(ScriptExecutionContext executionContext, CallbackArguments args) { Script S = executionContext.GetScript(); @@ -213,7 +213,7 @@ public static DynValue __require_clr_impl(ScriptExecutionContext executionContex } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public const string require = @" function(modulename) if (package == nil) then package = { }; end diff --git a/src/MoonSharp.Interpreter/CoreLib/MathModule.cs b/src/WattleScript.Interpreter/CoreLib/MathModule.cs similarity index 89% rename from src/MoonSharp.Interpreter/CoreLib/MathModule.cs rename to src/WattleScript.Interpreter/CoreLib/MathModule.cs index 352f81ca..cab8c9c8 100644 --- a/src/MoonSharp.Interpreter/CoreLib/MathModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/MathModule.cs @@ -2,19 +2,19 @@ #pragma warning disable 1591 using System; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.Interop; -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing math Lua functions /// - [MoonSharpModule(Namespace = "math")] + [WattleScriptModule(Namespace = "math")] public class MathModule { - [MoonSharpModuleConstant] + [WattleScriptModuleConstant] public const double pi = Math.PI; - [MoonSharpModuleConstant] + [WattleScriptModuleConstant] public const double huge = double.MaxValue; private static Random GetRandom(Script s) @@ -30,7 +30,7 @@ private static void SetRandom(Script s, Random random) } - public static void MoonSharpInit(Table globalTable, Table ioTable) + public static void WattleScriptInit(Table globalTable, Table ioTable) { SetRandom(globalTable.OwnerScript, new Random()); } @@ -79,79 +79,79 @@ private static DynValue execaccum(CallbackArguments args, string funcName, Func< } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue abs(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "abs", d => Math.Abs(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue acos(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "acos", d => Math.Acos(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue asin(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "asin", d => Math.Asin(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue atan(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "atan", d => Math.Atan(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue atan2(ScriptExecutionContext executionContext, CallbackArguments args) { return exec2(args, "atan2", (d1, d2) => Math.Atan2(d1, d2)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue ceil(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "ceil", d => Math.Ceiling(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue cos(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "cos", d => Math.Cos(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue cosh(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "cosh", d => Math.Cosh(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue deg(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "deg", d => d * 180.0 / Math.PI); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue exp(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "exp", d => Math.Exp(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue floor(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "floor", d => Math.Floor(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue fmod(ScriptExecutionContext executionContext, CallbackArguments args) { return exec2(args, "fmod", (d1, d2) => Math.IEEERemainder(d1, d2)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue frexp(ScriptExecutionContext executionContext, CallbackArguments args) { // http://stackoverflow.com/questions/389993/extracting-mantissa-and-exponent-from-double-in-c-sharp @@ -210,31 +210,31 @@ public static DynValue frexp(ScriptExecutionContext executionContext, CallbackAr return DynValue.NewTuple(DynValue.NewNumber(m), DynValue.NewNumber(e)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue ldexp(ScriptExecutionContext executionContext, CallbackArguments args) { return exec2(args, "ldexp", (d1, d2) => d1 * Math.Pow(2, d2)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue log(ScriptExecutionContext executionContext, CallbackArguments args) { return exec2n(args, "log", Math.E, (d1, d2) => Math.Log(d1, d2)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue max(ScriptExecutionContext executionContext, CallbackArguments args) { return execaccum(args, "max", (d1, d2) => Math.Max(d1, d2)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue min(ScriptExecutionContext executionContext, CallbackArguments args) { return execaccum(args, "min", (d1, d2) => Math.Min(d1, d2)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue modf(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue arg = args.AsType(0, "modf", DataType.Number, false); @@ -242,19 +242,19 @@ public static DynValue modf(ScriptExecutionContext executionContext, CallbackArg } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue pow(ScriptExecutionContext executionContext, CallbackArguments args) { return exec2(args, "pow", (d1, d2) => Math.Pow(d1, d2)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue rad(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "rad", d => d * Math.PI / 180.0); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue random(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue m = args.AsType(0, "random", DataType.Number, true); @@ -280,7 +280,7 @@ public static DynValue random(ScriptExecutionContext executionContext, CallbackA return DynValue.NewNumber(d); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue randomseed(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue arg = args.AsType(0, "randomseed", DataType.Number, false); @@ -289,31 +289,31 @@ public static DynValue randomseed(ScriptExecutionContext executionContext, Callb return DynValue.Nil; } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue sin(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "sin", d => Math.Sin(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue sinh(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "sinh", d => Math.Sinh(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue sqrt(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "sqrt", d => Math.Sqrt(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue tan(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "tan", d => Math.Tan(d)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue tanh(ScriptExecutionContext executionContext, CallbackArguments args) { return exec1(args, "tanh", d => Math.Tanh(d)); diff --git a/src/MoonSharp.Interpreter/CoreLib/MetaTableModule.cs b/src/WattleScript.Interpreter/CoreLib/MetaTableModule.cs similarity index 94% rename from src/MoonSharp.Interpreter/CoreLib/MetaTableModule.cs rename to src/WattleScript.Interpreter/CoreLib/MetaTableModule.cs index a6e224e7..096f6348 100644 --- a/src/MoonSharp.Interpreter/CoreLib/MetaTableModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/MetaTableModule.cs @@ -2,12 +2,12 @@ #pragma warning disable 1591 -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing metatable related Lua functions (xxxmetatable and rawxxx). /// - [MoonSharpModule] + [WattleScriptModule] public class MetaTableModule { // setmetatable (table, metatable) @@ -16,7 +16,7 @@ public class MetaTableModule // types from Lua, only from C.) If metatable is nil, removes the metatable of the given table. // If the original metatable has a "__metatable" field, raises an error ("cannot change a protected metatable"). // This function returns table. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue setmetatable(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue table = args.AsType(0, "setmetatable", DataType.Table); @@ -37,7 +37,7 @@ public static DynValue setmetatable(ScriptExecutionContext executionContext, Cal // ------------------------------------------------------------------------------------------------------------------- // If object does not have a metatable, returns nil. Otherwise, if the object's metatable // has a "__metatable" field, returns the associated value. Otherwise, returns the metatable of the given object. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue getmetatable(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue obj = args[0]; @@ -65,7 +65,7 @@ public static DynValue getmetatable(ScriptExecutionContext executionContext, Cal // rawget (table, index) // ------------------------------------------------------------------------------------------------------------------- // Gets the real value of table[index], without invoking any metamethod. table must be a table; index may be any value. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue rawget(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue table = args.AsType(0, "rawget", DataType.Table); @@ -79,7 +79,7 @@ public static DynValue rawget(ScriptExecutionContext executionContext, CallbackA // Sets the real value of table[index] to value, without invoking any metamethod. table must be a table, // index any value different from nil and NaN, and value any Lua value. // This function returns table. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue rawset(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue table = args.AsType(0, "rawset", DataType.Table); @@ -93,7 +93,7 @@ public static DynValue rawset(ScriptExecutionContext executionContext, CallbackA // rawequal (v1, v2) // ------------------------------------------------------------------------------------------------------------------- // Checks whether v1 is equal to v2, without invoking any metamethod. Returns a boolean. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue rawequal(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue v1 = args[0]; @@ -105,7 +105,7 @@ public static DynValue rawequal(ScriptExecutionContext executionContext, Callbac //rawlen (v) // ------------------------------------------------------------------------------------------------------------------- //Returns the length of the object v, which must be a table or a string, without invoking any metamethod. Returns an integer number. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue rawlen(ScriptExecutionContext executionContext, CallbackArguments args) { if (args[0].Type != DataType.String && args[0].Type != DataType.Table) diff --git a/src/MoonSharp.Interpreter/CoreLib/OsSystemModule.cs b/src/WattleScript.Interpreter/CoreLib/OsSystemModule.cs similarity index 92% rename from src/MoonSharp.Interpreter/CoreLib/OsSystemModule.cs rename to src/WattleScript.Interpreter/CoreLib/OsSystemModule.cs index 96edab57..79d33c06 100644 --- a/src/MoonSharp.Interpreter/CoreLib/OsSystemModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/OsSystemModule.cs @@ -3,16 +3,16 @@ using System; -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing system related Lua functions from the 'os' module. /// Proper support requires a compatible IPlatformAccessor /// - [MoonSharpModule(Namespace = "os")] + [WattleScriptModule(Namespace = "os")] public class OsSystemModule { - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue execute(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue v = args.AsType(0, "execute", DataType.String, true); @@ -40,7 +40,7 @@ public static DynValue execute(ScriptExecutionContext executionContext, Callback } } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue exit(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue v_exitCode = args.AsType(0, "exit", DataType.Number, true); @@ -54,7 +54,7 @@ public static DynValue exit(ScriptExecutionContext executionContext, CallbackArg throw new InvalidOperationException("Unreachable code.. reached."); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue getenv(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue varName = args.AsType(0, "getenv", DataType.String, false); @@ -67,7 +67,7 @@ public static DynValue getenv(ScriptExecutionContext executionContext, CallbackA return DynValue.NewString(val); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue remove(ScriptExecutionContext executionContext, CallbackArguments args) { string fileName = args.AsType(0, "remove", DataType.String, false).String; @@ -93,7 +93,7 @@ public static DynValue remove(ScriptExecutionContext executionContext, CallbackA } } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue rename(ScriptExecutionContext executionContext, CallbackArguments args) { string fileNameOld = args.AsType(0, "rename", DataType.String, false).String; @@ -117,13 +117,13 @@ public static DynValue rename(ScriptExecutionContext executionContext, CallbackA } } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue setlocale(ScriptExecutionContext executionContext, CallbackArguments args) { return DynValue.NewString("n/a"); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue tmpname(ScriptExecutionContext executionContext, CallbackArguments args) { return DynValue.NewString(Script.GlobalOptions.Platform.IO_OS_GetTempFilename()); diff --git a/src/MoonSharp.Interpreter/CoreLib/OsTimeModule.cs b/src/WattleScript.Interpreter/CoreLib/OsTimeModule.cs similarity index 97% rename from src/MoonSharp.Interpreter/CoreLib/OsTimeModule.cs rename to src/WattleScript.Interpreter/CoreLib/OsTimeModule.cs index ad89ce70..ea8d3916 100755 --- a/src/MoonSharp.Interpreter/CoreLib/OsTimeModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/OsTimeModule.cs @@ -5,12 +5,12 @@ using System.Collections.Generic; using System.Text; -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing time related Lua functions from the 'os' module. /// - [MoonSharpModule(Namespace = "os")] + [WattleScriptModule(Namespace = "os")] public class OsTimeModule { static DateTime Time0 = DateTime.UtcNow; @@ -32,7 +32,7 @@ private static DateTime FromUnixTime(double unixtime) return Epoch + ts; } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue clock(ScriptExecutionContext executionContext, CallbackArguments args) { var t = GetUnixTime(DateTime.UtcNow, Time0); @@ -40,7 +40,7 @@ public static DynValue clock(ScriptExecutionContext executionContext, CallbackAr return t; } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue difftime(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue t2 = args.AsType(0, "difftime", DataType.Number, false); @@ -52,7 +52,7 @@ public static DynValue difftime(ScriptExecutionContext executionContext, Callbac return DynValue.NewNumber(t2.Number - t1.Number); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue time(ScriptExecutionContext executionContext, CallbackArguments args) { DateTime date = DateTime.UtcNow; @@ -100,7 +100,7 @@ static DateTime ParseTimeTable(Table t) return null; } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue date(ScriptExecutionContext executionContext, CallbackArguments args) { DateTime reference = DateTime.UtcNow; diff --git a/src/MoonSharp.Interpreter/CoreLib/StringLib/KopiLua_StrLib.cs b/src/WattleScript.Interpreter/CoreLib/StringLib/KopiLua_StrLib.cs similarity index 99% rename from src/MoonSharp.Interpreter/CoreLib/StringLib/KopiLua_StrLib.cs rename to src/WattleScript.Interpreter/CoreLib/StringLib/KopiLua_StrLib.cs index cd51912c..49518ea8 100644 --- a/src/MoonSharp.Interpreter/CoreLib/StringLib/KopiLua_StrLib.cs +++ b/src/WattleScript.Interpreter/CoreLib/StringLib/KopiLua_StrLib.cs @@ -48,13 +48,13 @@ // THE SOFTWARE. -using MoonSharp.Interpreter.Interop.LuaStateInterop; +using WattleScript.Interpreter.Interop.LuaStateInterop; using lua_Integer = System.Int32; using LUA_INTFRM_T = System.Int64; using ptrdiff_t = System.Int32; using UNSIGNED_LUA_INTFRM_T = System.UInt64; -namespace MoonSharp.Interpreter.CoreLib.StringLib +namespace WattleScript.Interpreter.CoreLib.StringLib { internal class KopiLua_StringLib : LuaBase { diff --git a/src/MoonSharp.Interpreter/CoreLib/StringLib/StringRange.cs b/src/WattleScript.Interpreter/CoreLib/StringLib/StringRange.cs similarity index 96% rename from src/MoonSharp.Interpreter/CoreLib/StringLib/StringRange.cs rename to src/WattleScript.Interpreter/CoreLib/StringLib/StringRange.cs index 34169fc7..d282245b 100644 --- a/src/MoonSharp.Interpreter/CoreLib/StringLib/StringRange.cs +++ b/src/WattleScript.Interpreter/CoreLib/StringLib/StringRange.cs @@ -2,7 +2,7 @@ #pragma warning disable 1591 -namespace MoonSharp.Interpreter.CoreLib.StringLib +namespace WattleScript.Interpreter.CoreLib.StringLib { internal class StringRange { diff --git a/src/MoonSharp.Interpreter/CoreLib/StringModule.cs b/src/WattleScript.Interpreter/CoreLib/StringModule.cs similarity index 90% rename from src/MoonSharp.Interpreter/CoreLib/StringModule.cs rename to src/WattleScript.Interpreter/CoreLib/StringModule.cs index bdfc8e49..8a7e4683 100644 --- a/src/MoonSharp.Interpreter/CoreLib/StringModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/StringModule.cs @@ -4,19 +4,19 @@ using System; using System.IO; using System.Text; -using MoonSharp.Interpreter.CoreLib.StringLib; +using WattleScript.Interpreter.CoreLib.StringLib; -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing string Lua functions /// - [MoonSharpModule(Namespace = "string")] + [WattleScriptModule(Namespace = "string")] public class StringModule { - public const string BASE64_DUMP_HEADER = "MoonSharp_dump_b64::"; + public const string BASE64_DUMP_HEADER = "WattleScript_dump_b64::"; - public static void MoonSharpInit(Table globalTable, Table stringTable) + public static void WattleScriptInit(Table globalTable, Table stringTable) { Table stringMetatable = new Table(globalTable.OwnerScript); stringMetatable.Set("__index", DynValue.NewTable(stringTable)); @@ -24,7 +24,7 @@ public static void MoonSharpInit(Table globalTable, Table stringTable) } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue dump(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue fn = args.AsType(0, "dump", DataType.Function, false); @@ -48,7 +48,7 @@ public static DynValue dump(ScriptExecutionContext executionContext, CallbackArg } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue @char(ScriptExecutionContext executionContext, CallbackArguments args) { StringBuilder sb = new StringBuilder(args.Count); @@ -79,7 +79,7 @@ public static DynValue @char(ScriptExecutionContext executionContext, CallbackAr } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue @byte(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue vs = args.AsType(0, "byte", DataType.String, false); @@ -90,7 +90,7 @@ public static DynValue @byte(ScriptExecutionContext executionContext, CallbackAr i => Unicode2Ascii(i)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue unicode(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue vs = args.AsType(0, "unicode", DataType.String, false); @@ -141,7 +141,7 @@ private static DynValue PerformByteLike(DynValue vs, DynValue vi, DynValue vj, F return s.Length - i; } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue len(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue vs = args.AsType(0, "len", DataType.String, false); @@ -150,26 +150,26 @@ public static DynValue len(ScriptExecutionContext executionContext, CallbackArgu - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue match(ScriptExecutionContext executionContext, CallbackArguments args) { return executionContext.EmulateClassicCall(args, "match", KopiLua_StringLib.str_match); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue gmatch(ScriptExecutionContext executionContext, CallbackArguments args) { return executionContext.EmulateClassicCall(args, "gmatch", KopiLua_StringLib.str_gmatch); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue gsub(ScriptExecutionContext executionContext, CallbackArguments args) { return executionContext.EmulateClassicCall(args, "gsub", KopiLua_StringLib.str_gsub); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue find(ScriptExecutionContext executionContext, CallbackArguments args) { return executionContext.EmulateClassicCall(args, "find", @@ -177,21 +177,21 @@ public static DynValue find(ScriptExecutionContext executionContext, CallbackArg } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue lower(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue arg_s = args.AsType(0, "lower", DataType.String, false); return DynValue.NewString(arg_s.String.ToLower()); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue upper(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue arg_s = args.AsType(0, "upper", DataType.String, false); return DynValue.NewString(arg_s.String.ToUpper()); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue rep(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue arg_s = args.AsType(0, "rep", DataType.String, false); @@ -219,7 +219,7 @@ public static DynValue rep(ScriptExecutionContext executionContext, CallbackArgu return DynValue.NewString(result.ToString()); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue format(ScriptExecutionContext executionContext, CallbackArguments args) { return executionContext.EmulateClassicCall(args, "format", KopiLua_StringLib.str_format); @@ -227,7 +227,7 @@ public static DynValue format(ScriptExecutionContext executionContext, CallbackA - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue reverse(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue arg_s = args.AsType(0, "reverse", DataType.String, false); @@ -243,7 +243,7 @@ public static DynValue reverse(ScriptExecutionContext executionContext, Callback return DynValue.NewString(new String(elements)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue sub(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue arg_s = args.AsType(0, "sub", DataType.String, false); @@ -256,7 +256,7 @@ public static DynValue sub(ScriptExecutionContext executionContext, CallbackArgu return DynValue.NewString(s); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue startsWith(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue arg_s1 = args.AsType(0, "startsWith", DataType.String, true); @@ -268,7 +268,7 @@ public static DynValue startsWith(ScriptExecutionContext executionContext, Callb return DynValue.NewBoolean(arg_s1.String.StartsWith(arg_s2.String)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue endsWith(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue arg_s1 = args.AsType(0, "endsWith", DataType.String, true); @@ -280,7 +280,7 @@ public static DynValue endsWith(ScriptExecutionContext executionContext, Callbac return DynValue.NewBoolean(arg_s1.String.EndsWith(arg_s2.String)); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue contains(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue arg_s1 = args.AsType(0, "contains", DataType.String, true); diff --git a/src/MoonSharp.Interpreter/CoreLib/TableIteratorsModule.cs b/src/WattleScript.Interpreter/CoreLib/TableIteratorsModule.cs similarity index 96% rename from src/MoonSharp.Interpreter/CoreLib/TableIteratorsModule.cs rename to src/WattleScript.Interpreter/CoreLib/TableIteratorsModule.cs index a5d95fe8..2ab42c10 100644 --- a/src/MoonSharp.Interpreter/CoreLib/TableIteratorsModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/TableIteratorsModule.cs @@ -2,12 +2,12 @@ #pragma warning disable 1591 -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing table Lua iterators (pairs, ipairs, next) /// - [MoonSharpModule] + [WattleScriptModule] public class TableIteratorsModule { // ipairs (t) @@ -16,7 +16,7 @@ public class TableIteratorsModule // Otherwise, returns three values: an iterator function, the table t, and 0, so that the construction // for i,v in ipairs(t) do body end // will iterate over the pairs (1,t[1]), (2,t[2]), ..., up to the first integer key absent from the table. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue ipairs(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue table = args[0]; @@ -33,7 +33,7 @@ public static DynValue ipairs(ScriptExecutionContext executionContext, CallbackA // for k,v in pairs(t) do body end // will iterate over all key–value pairs of table t. // See function next for the caveats of modifying the table during its traversal. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue pairs(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue table = args[0]; @@ -54,7 +54,7 @@ public static DynValue pairs(ScriptExecutionContext executionContext, CallbackAr // (To traverse a table in numeric order, use a numerical for.) // The behavior of next is undefined if, during the traversal, you assign any value to a non-existent field in the table. // You may however modify existing fields. In particular, you may clear existing fields. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue next(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue table = args.AsType(0, "next", DataType.Table); diff --git a/src/MoonSharp.Interpreter/CoreLib/TableModule.cs b/src/WattleScript.Interpreter/CoreLib/TableModule.cs similarity index 95% rename from src/MoonSharp.Interpreter/CoreLib/TableModule.cs rename to src/WattleScript.Interpreter/CoreLib/TableModule.cs index 593bcc01..fa8e37b6 100644 --- a/src/MoonSharp.Interpreter/CoreLib/TableModule.cs +++ b/src/WattleScript.Interpreter/CoreLib/TableModule.cs @@ -5,15 +5,15 @@ using System.Collections.Generic; using System.Text; -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// /// Class implementing table Lua functions /// - [MoonSharpModule(Namespace = "table")] + [WattleScriptModule(Namespace = "table")] public class TableModule { - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue unpack(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue s = args.AsType(0, "unpack", DataType.Table, false); @@ -34,7 +34,7 @@ public static DynValue unpack(ScriptExecutionContext executionContext, CallbackA return DynValue.NewTuple(v); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue pack(ScriptExecutionContext executionContext, CallbackArguments args) { Table t = new Table(executionContext.GetScript()); @@ -48,7 +48,7 @@ public static DynValue pack(ScriptExecutionContext executionContext, CallbackArg return v; } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue sort(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue vlist = args.AsType(0, "sort", DataType.Table, false); @@ -128,7 +128,7 @@ private static int LuaComparerToClrComparer(DynValue dynValue1, DynValue dynValu return 0; } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue insert(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue vlist = args.AsType(0, "table.insert", DataType.Table, false); @@ -166,7 +166,7 @@ public static DynValue insert(ScriptExecutionContext executionContext, CallbackA } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue remove(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue vlist = args.AsType(0, "table.remove", DataType.Table, false); @@ -200,7 +200,7 @@ public static DynValue remove(ScriptExecutionContext executionContext, CallbackA //Given a list where all elements are strings or numbers, returns the string list[i]..sep..list[i+1] (...) sep..list[j]. //The default value for sep is the empty string, the default for i is 1, and the default for j is #list. If i is greater //than j, returns the empty string. - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue concat(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue vlist = args.AsType(0, "concat", DataType.Table, false); @@ -263,16 +263,16 @@ private static int GetTableLength(ScriptExecutionContext executionContext, DynVa /// /// Class exposing table.unpack and table.pack in the global namespace (to work around the most common Lua 5.1 compatibility issue). /// - [MoonSharpModule] + [WattleScriptModule] public class TableModule_Globals { - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue unpack(ScriptExecutionContext executionContext, CallbackArguments args) { return TableModule.unpack(executionContext, args); } - [MoonSharpModuleMethod] + [WattleScriptModuleMethod] public static DynValue pack(ScriptExecutionContext executionContext, CallbackArguments args) { return TableModule.pack(executionContext, args); diff --git a/src/MoonSharp.Interpreter/DataStructs/Extension_Methods.cs b/src/WattleScript.Interpreter/DataStructs/Extension_Methods.cs similarity index 97% rename from src/MoonSharp.Interpreter/DataStructs/Extension_Methods.cs rename to src/WattleScript.Interpreter/DataStructs/Extension_Methods.cs index e2176f81..27726d1d 100644 --- a/src/MoonSharp.Interpreter/DataStructs/Extension_Methods.cs +++ b/src/WattleScript.Interpreter/DataStructs/Extension_Methods.cs @@ -1,7 +1,7 @@ using System; using System.Collections.Generic; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Extension methods used in the whole project. diff --git a/src/MoonSharp.Interpreter/DataStructs/FastStack.cs b/src/WattleScript.Interpreter/DataStructs/FastStack.cs similarity index 98% rename from src/MoonSharp.Interpreter/DataStructs/FastStack.cs rename to src/WattleScript.Interpreter/DataStructs/FastStack.cs index 3ac9a3b0..60dcc400 100644 --- a/src/MoonSharp.Interpreter/DataStructs/FastStack.cs +++ b/src/WattleScript.Interpreter/DataStructs/FastStack.cs @@ -3,7 +3,7 @@ using System; using System.Collections.Generic; -namespace MoonSharp.Interpreter.DataStructs +namespace WattleScript.Interpreter.DataStructs { /// /// A preallocated, non-resizable, stack diff --git a/src/MoonSharp.Interpreter/DataStructs/LinkedListArrayIndex.cs b/src/WattleScript.Interpreter/DataStructs/LinkedListArrayIndex.cs similarity index 98% rename from src/MoonSharp.Interpreter/DataStructs/LinkedListArrayIndex.cs rename to src/WattleScript.Interpreter/DataStructs/LinkedListArrayIndex.cs index 2d2ee362..c79bb2ea 100644 --- a/src/MoonSharp.Interpreter/DataStructs/LinkedListArrayIndex.cs +++ b/src/WattleScript.Interpreter/DataStructs/LinkedListArrayIndex.cs @@ -1,7 +1,7 @@ using System; using System.Collections.Generic; -namespace MoonSharp.Interpreter.DataStructs +namespace WattleScript.Interpreter.DataStructs { internal class LinkedListArrayIndex : LinkedListIndex { diff --git a/src/MoonSharp.Interpreter/DataStructs/LinkedListIndex.cs b/src/WattleScript.Interpreter/DataStructs/LinkedListIndex.cs similarity index 98% rename from src/MoonSharp.Interpreter/DataStructs/LinkedListIndex.cs rename to src/WattleScript.Interpreter/DataStructs/LinkedListIndex.cs index 374d3cdf..7a7664b2 100644 --- a/src/MoonSharp.Interpreter/DataStructs/LinkedListIndex.cs +++ b/src/WattleScript.Interpreter/DataStructs/LinkedListIndex.cs @@ -1,6 +1,6 @@ using System.Collections.Generic; -namespace MoonSharp.Interpreter.DataStructs +namespace WattleScript.Interpreter.DataStructs { /// /// An index to accelerate operations on a LinkedList using a single key of type diff --git a/src/MoonSharp.Interpreter/DataStructs/MultiDictionary.cs b/src/WattleScript.Interpreter/DataStructs/MultiDictionary.cs similarity index 98% rename from src/MoonSharp.Interpreter/DataStructs/MultiDictionary.cs rename to src/WattleScript.Interpreter/DataStructs/MultiDictionary.cs index 925b7b8e..23cc4f0e 100644 --- a/src/MoonSharp.Interpreter/DataStructs/MultiDictionary.cs +++ b/src/WattleScript.Interpreter/DataStructs/MultiDictionary.cs @@ -1,6 +1,6 @@ using System.Collections.Generic; -namespace MoonSharp.Interpreter.DataStructs +namespace WattleScript.Interpreter.DataStructs { /// /// A Dictionary where multiple values can be associated to the same key diff --git a/src/MoonSharp.Interpreter/DataStructs/ReferenceEqualityComparer.cs b/src/WattleScript.Interpreter/DataStructs/ReferenceEqualityComparer.cs similarity index 89% rename from src/MoonSharp.Interpreter/DataStructs/ReferenceEqualityComparer.cs rename to src/WattleScript.Interpreter/DataStructs/ReferenceEqualityComparer.cs index 13ea0b57..0d58b3c3 100644 --- a/src/MoonSharp.Interpreter/DataStructs/ReferenceEqualityComparer.cs +++ b/src/WattleScript.Interpreter/DataStructs/ReferenceEqualityComparer.cs @@ -1,6 +1,6 @@ using System.Collections.Generic; -namespace MoonSharp.Interpreter.DataStructs +namespace WattleScript.Interpreter.DataStructs { /// /// Implementation of IEqualityComparer enforcing reference equality diff --git a/src/MoonSharp.Interpreter/DataStructs/Slice.cs b/src/WattleScript.Interpreter/DataStructs/Slice.cs similarity index 99% rename from src/MoonSharp.Interpreter/DataStructs/Slice.cs rename to src/WattleScript.Interpreter/DataStructs/Slice.cs index 0150fa0f..d5eaef5d 100644 --- a/src/MoonSharp.Interpreter/DataStructs/Slice.cs +++ b/src/WattleScript.Interpreter/DataStructs/Slice.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Interpreter.DataStructs +namespace WattleScript.Interpreter.DataStructs { /// /// Provides facility to create a "sliced" view over an existing IList diff --git a/src/MoonSharp.Interpreter/DataTypes/Annotation.cs b/src/WattleScript.Interpreter/DataTypes/Annotation.cs similarity index 91% rename from src/MoonSharp.Interpreter/DataTypes/Annotation.cs rename to src/WattleScript.Interpreter/DataTypes/Annotation.cs index 515cac4d..6baac76d 100644 --- a/src/MoonSharp.Interpreter/DataTypes/Annotation.cs +++ b/src/WattleScript.Interpreter/DataTypes/Annotation.cs @@ -1,4 +1,4 @@ -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { public class Annotation { diff --git a/src/MoonSharp.Interpreter/DataTypes/CallbackArguments.cs b/src/WattleScript.Interpreter/DataTypes/CallbackArguments.cs similarity index 98% rename from src/MoonSharp.Interpreter/DataTypes/CallbackArguments.cs rename to src/WattleScript.Interpreter/DataTypes/CallbackArguments.cs index a596cba4..e52b934c 100644 --- a/src/MoonSharp.Interpreter/DataTypes/CallbackArguments.cs +++ b/src/WattleScript.Interpreter/DataTypes/CallbackArguments.cs @@ -1,7 +1,7 @@ using System.Collections.Generic; -using MoonSharp.Interpreter.DataStructs; +using WattleScript.Interpreter.DataStructs; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// This class is a container for arguments received by a CallbackFunction diff --git a/src/MoonSharp.Interpreter/DataTypes/CallbackFunction.cs b/src/WattleScript.Interpreter/DataTypes/CallbackFunction.cs similarity index 98% rename from src/MoonSharp.Interpreter/DataTypes/CallbackFunction.cs rename to src/WattleScript.Interpreter/DataTypes/CallbackFunction.cs index ea164baf..dd0aa8e1 100755 --- a/src/MoonSharp.Interpreter/DataTypes/CallbackFunction.cs +++ b/src/WattleScript.Interpreter/DataTypes/CallbackFunction.cs @@ -1,9 +1,9 @@ using System; using System.Collections.Generic; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.Interop; using System.Reflection; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// This class wraps a CLR function diff --git a/src/MoonSharp.Interpreter/DataTypes/Closure.cs b/src/WattleScript.Interpreter/DataTypes/Closure.cs similarity index 98% rename from src/MoonSharp.Interpreter/DataTypes/Closure.cs rename to src/WattleScript.Interpreter/DataTypes/Closure.cs index 5f19590a..1e7dc9fd 100644 --- a/src/MoonSharp.Interpreter/DataTypes/Closure.cs +++ b/src/WattleScript.Interpreter/DataTypes/Closure.cs @@ -1,9 +1,9 @@ using System; using System.Collections.Generic; using System.Threading.Tasks; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Execution; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// A class representing a script function diff --git a/src/MoonSharp.Interpreter/DataTypes/Coroutine.cs b/src/WattleScript.Interpreter/DataTypes/Coroutine.cs similarity index 97% rename from src/MoonSharp.Interpreter/DataTypes/Coroutine.cs rename to src/WattleScript.Interpreter/DataTypes/Coroutine.cs index c1b37b58..297db020 100755 --- a/src/MoonSharp.Interpreter/DataTypes/Coroutine.cs +++ b/src/WattleScript.Interpreter/DataTypes/Coroutine.cs @@ -1,10 +1,10 @@ using System; using System.Collections.Generic; using System.Linq; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// A class representing a script coroutine @@ -110,7 +110,7 @@ public IEnumerable AsEnumerable() } /// - /// The purpose of this method is to convert a MoonSharp/Lua coroutine to a Unity3D coroutine. + /// The purpose of this method is to convert a WattleScript/Lua coroutine to a Unity3D coroutine. /// This loops over the coroutine, discarding returned values, and returning null for each invocation. /// This means however that the coroutine will be invoked each frame. /// Only non-CLR coroutines can be resumed with this method. Use an overload of the Resume method accepting a ScriptExecutionContext instead. diff --git a/src/MoonSharp.Interpreter/DataTypes/CoroutineState.cs b/src/WattleScript.Interpreter/DataTypes/CoroutineState.cs similarity index 94% rename from src/MoonSharp.Interpreter/DataTypes/CoroutineState.cs rename to src/WattleScript.Interpreter/DataTypes/CoroutineState.cs index 029b8893..7fe7bf22 100644 --- a/src/MoonSharp.Interpreter/DataTypes/CoroutineState.cs +++ b/src/WattleScript.Interpreter/DataTypes/CoroutineState.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// State of coroutines diff --git a/src/MoonSharp.Interpreter/DataTypes/DataType.cs b/src/WattleScript.Interpreter/DataTypes/DataType.cs similarity index 97% rename from src/MoonSharp.Interpreter/DataTypes/DataType.cs rename to src/WattleScript.Interpreter/DataTypes/DataType.cs index 59f07bbc..09e19ad1 100644 --- a/src/MoonSharp.Interpreter/DataTypes/DataType.cs +++ b/src/WattleScript.Interpreter/DataTypes/DataType.cs @@ -1,9 +1,9 @@  -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// - /// Enumeration of possible data types in MoonSharp + /// Enumeration of possible data types in WattleScript /// public enum DataType { diff --git a/src/MoonSharp.Interpreter/DataTypes/DynValue.cs b/src/WattleScript.Interpreter/DataTypes/DynValue.cs similarity index 96% rename from src/MoonSharp.Interpreter/DataTypes/DynValue.cs rename to src/WattleScript.Interpreter/DataTypes/DynValue.cs index 40eefa58..0cc7817b 100644 --- a/src/MoonSharp.Interpreter/DataTypes/DynValue.cs +++ b/src/WattleScript.Interpreter/DataTypes/DynValue.cs @@ -6,12 +6,12 @@ using System.Runtime.InteropServices; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter.Tree; +using WattleScript.Interpreter.Tree; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// - /// A class representing a value in a Lua/MoonSharp script. + /// A class representing a value in a Lua/WattleScript script. /// [StructLayout(LayoutKind.Explicit)] public struct DynValue @@ -245,7 +245,7 @@ public static DynValue NewTable(Script script, params DynValue[] arrayValues) } /// - /// Creates a new request for a tail call. This is the preferred way to execute Lua/MoonSharp code from a callback, + /// Creates a new request for a tail call. This is the preferred way to execute Lua/WattleScript code from a callback, /// although it's not always possible to use it. When a function (callback or script closure) returns a /// TailCallRequest, the bytecode processor immediately executes the function contained in the request. /// By executing script in this way, a callback function ensures it's not on the stack anymore and thus a number @@ -268,7 +268,7 @@ public static DynValue NewTailCallReq(DynValue tailFn, params DynValue[] args) } /// - /// Creates a new request for a tail call. This is the preferred way to execute Lua/MoonSharp code from a callback, + /// Creates a new request for a tail call. This is the preferred way to execute Lua/WattleScript code from a callback, /// although it's not always possible to use it. When a function (callback or script closure) returns a /// TailCallRequest, the bytecode processor immediately executes the function contained in the request. /// By executing script in this way, a callback function ensures it's not on the stack anymore and thus a number @@ -985,28 +985,28 @@ public bool IsNilOrNan() /// public static DynValue FromObject(Script script, object obj) { - return MoonSharp.Interpreter.Interop.Converters.ClrToScriptConversions.ObjectToDynValue(script, obj); + return WattleScript.Interpreter.Interop.Converters.ClrToScriptConversions.ObjectToDynValue(script, obj); } /// - /// Converts this MoonSharp DynValue to a CLR object. + /// Converts this WattleScript DynValue to a CLR object. /// public object ToObject() { - return MoonSharp.Interpreter.Interop.Converters.ScriptToClrConversions.DynValueToObject(this); + return WattleScript.Interpreter.Interop.Converters.ScriptToClrConversions.DynValueToObject(this); } /// - /// Converts this MoonSharp DynValue to a CLR object of the specified type. + /// Converts this WattleScript DynValue to a CLR object of the specified type. /// public object ToObject(Type desiredType) { //Contract.Requires(desiredType != null); - return MoonSharp.Interpreter.Interop.Converters.ScriptToClrConversions.DynValueToObjectOfType(this, desiredType, null, false); + return WattleScript.Interpreter.Interop.Converters.ScriptToClrConversions.DynValueToObjectOfType(this, desiredType, null, false); } /// - /// Converts this MoonSharp DynValue to a CLR object of the specified type. + /// Converts this WattleScript DynValue to a CLR object of the specified type. /// public T ToObject() { @@ -1020,11 +1020,11 @@ public T ToObject() #if HASDYNAMIC /// - /// Converts this MoonSharp DynValue to a CLR object, marked as dynamic + /// Converts this WattleScript DynValue to a CLR object, marked as dynamic /// public dynamic ToDynamic() { - return MoonSharp.Interpreter.Interop.Converters.ScriptToClrConversions.DynValueToObject(this); + return WattleScript.Interpreter.Interop.Converters.ScriptToClrConversions.DynValueToObject(this); } #endif diff --git a/src/MoonSharp.Interpreter/DataTypes/IScriptPrivateResource.cs b/src/WattleScript.Interpreter/DataTypes/IScriptPrivateResource.cs similarity index 98% rename from src/MoonSharp.Interpreter/DataTypes/IScriptPrivateResource.cs rename to src/WattleScript.Interpreter/DataTypes/IScriptPrivateResource.cs index 9f8c183c..945e56aa 100644 --- a/src/MoonSharp.Interpreter/DataTypes/IScriptPrivateResource.cs +++ b/src/WattleScript.Interpreter/DataTypes/IScriptPrivateResource.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Common interface for all resources which are uniquely bound to a script. diff --git a/src/MoonSharp.Interpreter/DataTypes/RefIdObject.cs b/src/WattleScript.Interpreter/DataTypes/RefIdObject.cs similarity index 91% rename from src/MoonSharp.Interpreter/DataTypes/RefIdObject.cs rename to src/WattleScript.Interpreter/DataTypes/RefIdObject.cs index 0569e363..f760daef 100644 --- a/src/MoonSharp.Interpreter/DataTypes/RefIdObject.cs +++ b/src/WattleScript.Interpreter/DataTypes/RefIdObject.cs @@ -1,8 +1,8 @@  -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// - /// A base class for many MoonSharp objects. + /// A base class for many WattleScript objects. /// Helds a ReferenceID property which gets a different value for every object instance, for debugging /// purposes. Note that the ID is not assigned in a thread safe manner for speed reason, so the IDs /// are guaranteed to be unique only if everything is running on one thread at a time. diff --git a/src/MoonSharp.Interpreter/DataTypes/ScriptFunctionDelegate.cs b/src/WattleScript.Interpreter/DataTypes/ScriptFunctionDelegate.cs similarity index 94% rename from src/MoonSharp.Interpreter/DataTypes/ScriptFunctionDelegate.cs rename to src/WattleScript.Interpreter/DataTypes/ScriptFunctionDelegate.cs index 805a3fe1..355e52d5 100644 --- a/src/MoonSharp.Interpreter/DataTypes/ScriptFunctionDelegate.cs +++ b/src/WattleScript.Interpreter/DataTypes/ScriptFunctionDelegate.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// A Delegate type which can wrap a script function diff --git a/src/MoonSharp.Interpreter/DataTypes/SymbolRef.cs b/src/WattleScript.Interpreter/DataTypes/SymbolRef.cs similarity index 98% rename from src/MoonSharp.Interpreter/DataTypes/SymbolRef.cs rename to src/WattleScript.Interpreter/DataTypes/SymbolRef.cs index 5818b1bd..99223b41 100644 --- a/src/MoonSharp.Interpreter/DataTypes/SymbolRef.cs +++ b/src/WattleScript.Interpreter/DataTypes/SymbolRef.cs @@ -1,8 +1,8 @@ using System.Collections.Generic; using System.IO; -using MoonSharp.Interpreter.IO; +using WattleScript.Interpreter.IO; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// This class stores a possible l-value (that is a potential target of an assignment) diff --git a/src/MoonSharp.Interpreter/DataTypes/SymbolRefType.cs b/src/WattleScript.Interpreter/DataTypes/SymbolRefType.cs similarity index 93% rename from src/MoonSharp.Interpreter/DataTypes/SymbolRefType.cs rename to src/WattleScript.Interpreter/DataTypes/SymbolRefType.cs index 75dd8a22..3c3213ad 100644 --- a/src/MoonSharp.Interpreter/DataTypes/SymbolRefType.cs +++ b/src/WattleScript.Interpreter/DataTypes/SymbolRefType.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Enumeration of the types of SymbolRef diff --git a/src/MoonSharp.Interpreter/DataTypes/Table.cs b/src/WattleScript.Interpreter/DataTypes/Table.cs similarity index 97% rename from src/MoonSharp.Interpreter/DataTypes/Table.cs rename to src/WattleScript.Interpreter/DataTypes/Table.cs index 9a22d093..1dfaed87 100644 --- a/src/MoonSharp.Interpreter/DataTypes/Table.cs +++ b/src/WattleScript.Interpreter/DataTypes/Table.cs @@ -1,9 +1,9 @@ using System.Collections.Generic; using System.Linq; using System.Runtime.CompilerServices; -using MoonSharp.Interpreter.DataStructs; +using WattleScript.Interpreter.DataStructs; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// A class representing a Lua table. @@ -81,7 +81,7 @@ private int GetIntegralKey(double d) /// /// Gets or sets the /// with the specified key(s). - /// This will marshall CLR and MoonSharp objects in the best possible way. + /// This will marshall CLR and WattleScript objects in the best possible way. /// Multiple keys can be used to access subtables. /// /// @@ -102,7 +102,7 @@ public object this[params object[] keys] /// /// Gets or sets the with the specified key(s). - /// This will marshall CLR and MoonSharp objects in the best possible way. + /// This will marshall CLR and WattleScript objects in the best possible way. /// /// /// The . @@ -388,7 +388,7 @@ public DynValue Get(object key) /// /// Gets the value associated with the specified keys (expressed as an /// array of ). - /// This will marshall CLR and MoonSharp objects in the best possible way. + /// This will marshall CLR and WattleScript objects in the best possible way. /// Multiple keys can be used to access subtables. /// /// The keys to access the table and subtables @@ -469,7 +469,7 @@ public DynValue RawGet(object key) /// /// Gets the value associated with the specified keys (expressed as an /// array of ). - /// This will marshall CLR and MoonSharp objects in the best possible way. + /// This will marshall CLR and WattleScript objects in the best possible way. /// Multiple keys can be used to access subtables. /// /// The keys to access the table and subtables diff --git a/src/MoonSharp.Interpreter/DataTypes/TablePair.cs b/src/WattleScript.Interpreter/DataTypes/TablePair.cs similarity index 96% rename from src/MoonSharp.Interpreter/DataTypes/TablePair.cs rename to src/WattleScript.Interpreter/DataTypes/TablePair.cs index 6045ab47..ce1e3595 100644 --- a/src/MoonSharp.Interpreter/DataTypes/TablePair.cs +++ b/src/WattleScript.Interpreter/DataTypes/TablePair.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// A class representing a key/value pair for Table use diff --git a/src/MoonSharp.Interpreter/DataTypes/TailCallData.cs b/src/WattleScript.Interpreter/DataTypes/TailCallData.cs similarity index 96% rename from src/MoonSharp.Interpreter/DataTypes/TailCallData.cs rename to src/WattleScript.Interpreter/DataTypes/TailCallData.cs index 13d7ba3f..affc1cb6 100644 --- a/src/MoonSharp.Interpreter/DataTypes/TailCallData.cs +++ b/src/WattleScript.Interpreter/DataTypes/TailCallData.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Class used to support "tail" continuations - a way for C# / Lua interaction which supports diff --git a/src/MoonSharp.Interpreter/DataTypes/TypeValidationFlags.cs b/src/WattleScript.Interpreter/DataTypes/TypeValidationFlags.cs similarity index 96% rename from src/MoonSharp.Interpreter/DataTypes/TypeValidationFlags.cs rename to src/WattleScript.Interpreter/DataTypes/TypeValidationFlags.cs index 1540f895..7fcee74d 100644 --- a/src/MoonSharp.Interpreter/DataTypes/TypeValidationFlags.cs +++ b/src/WattleScript.Interpreter/DataTypes/TypeValidationFlags.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Flags to alter the way the DynValue.CheckType and other related functions operate on data types for diff --git a/src/MoonSharp.Interpreter/DataTypes/UserData.cs b/src/WattleScript.Interpreter/DataTypes/UserData.cs similarity index 96% rename from src/MoonSharp.Interpreter/DataTypes/UserData.cs rename to src/WattleScript.Interpreter/DataTypes/UserData.cs index e37ed5f0..b6564dcb 100755 --- a/src/MoonSharp.Interpreter/DataTypes/UserData.cs +++ b/src/WattleScript.Interpreter/DataTypes/UserData.cs @@ -2,14 +2,14 @@ using System.Collections.Generic; using System.Reflection; using System.Linq; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.RegistrationPolicies; -using MoonSharp.Interpreter.Interop.StandardDescriptors; -using MoonSharp.Interpreter.Interop.UserDataRegistries; -using MoonSharp.Interpreter.Serialization.Json; - -namespace MoonSharp.Interpreter +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.RegistrationPolicies; +using WattleScript.Interpreter.Interop.StandardDescriptors; +using WattleScript.Interpreter.Interop.UserDataRegistries; +using WattleScript.Interpreter.Serialization.Json; + +namespace WattleScript.Interpreter { /// /// Class exposing C# objects as Lua userdata. @@ -137,7 +137,7 @@ public static IUserDataDescriptor RegisterType(IUserDataDescriptor customDescrip /// - /// Registers all types marked with a MoonSharpUserDataAttribute that ar contained in an assembly. + /// Registers all types marked with a WattleScriptUserDataAttribute that ar contained in an assembly. /// /// The assembly. /// if set to true extension types are registered to the appropriate registry. diff --git a/src/MoonSharp.Interpreter/DataTypes/WellKnownSymbols.cs b/src/WattleScript.Interpreter/DataTypes/WellKnownSymbols.cs similarity index 75% rename from src/MoonSharp.Interpreter/DataTypes/WellKnownSymbols.cs rename to src/WattleScript.Interpreter/DataTypes/WellKnownSymbols.cs index ed78ef3f..9d1a72b3 100644 --- a/src/MoonSharp.Interpreter/DataTypes/WellKnownSymbols.cs +++ b/src/WattleScript.Interpreter/DataTypes/WellKnownSymbols.cs @@ -1,8 +1,8 @@  -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// - /// Constants of well known "symbols" in the MoonSharp grammar + /// Constants of well known "symbols" in the WattleScript grammar /// public static class WellKnownSymbols { diff --git a/src/MoonSharp.Interpreter/DataTypes/YieldRequest.cs b/src/WattleScript.Interpreter/DataTypes/YieldRequest.cs similarity index 92% rename from src/MoonSharp.Interpreter/DataTypes/YieldRequest.cs rename to src/WattleScript.Interpreter/DataTypes/YieldRequest.cs index a46a3cb0..89d25839 100644 --- a/src/MoonSharp.Interpreter/DataTypes/YieldRequest.cs +++ b/src/WattleScript.Interpreter/DataTypes/YieldRequest.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Class wrapping a request to yield a coroutine diff --git a/src/MoonSharp.Interpreter/Debugging/DebugService.cs b/src/WattleScript.Interpreter/Debugging/DebugService.cs similarity index 86% rename from src/MoonSharp.Interpreter/Debugging/DebugService.cs rename to src/WattleScript.Interpreter/Debugging/DebugService.cs index 28802d93..da1011ee 100644 --- a/src/MoonSharp.Interpreter/Debugging/DebugService.cs +++ b/src/WattleScript.Interpreter/Debugging/DebugService.cs @@ -2,14 +2,14 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Debugging +namespace WattleScript.Interpreter.Debugging { /// /// Class providing services specific to debugger implementations. /// - /// + /// public sealed class DebugService : IScriptPrivateResource { Processor m_Processor; diff --git a/src/MoonSharp.Interpreter/Debugging/DebuggerAction.cs b/src/WattleScript.Interpreter/Debugging/DebuggerAction.cs similarity index 98% rename from src/MoonSharp.Interpreter/Debugging/DebuggerAction.cs rename to src/WattleScript.Interpreter/Debugging/DebuggerAction.cs index 270df3bc..31d3e995 100644 --- a/src/MoonSharp.Interpreter/Debugging/DebuggerAction.cs +++ b/src/WattleScript.Interpreter/Debugging/DebuggerAction.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Debugging +namespace WattleScript.Interpreter.Debugging { /// /// Wrapper for a debugger initiated action diff --git a/src/MoonSharp.Interpreter/Debugging/DebuggerCaps.cs b/src/WattleScript.Interpreter/Debugging/DebuggerCaps.cs similarity index 92% rename from src/MoonSharp.Interpreter/Debugging/DebuggerCaps.cs rename to src/WattleScript.Interpreter/Debugging/DebuggerCaps.cs index 415866d7..7fbc6ce6 100644 --- a/src/MoonSharp.Interpreter/Debugging/DebuggerCaps.cs +++ b/src/WattleScript.Interpreter/Debugging/DebuggerCaps.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Interpreter.Debugging +namespace WattleScript.Interpreter.Debugging { /// /// Enumeration of capabilities for a debugger diff --git a/src/MoonSharp.Interpreter/Debugging/IDebugger.cs b/src/WattleScript.Interpreter/Debugging/IDebugger.cs similarity index 98% rename from src/MoonSharp.Interpreter/Debugging/IDebugger.cs rename to src/WattleScript.Interpreter/Debugging/IDebugger.cs index 8e2e4dca..07a55e0b 100644 --- a/src/MoonSharp.Interpreter/Debugging/IDebugger.cs +++ b/src/WattleScript.Interpreter/Debugging/IDebugger.cs @@ -1,6 +1,6 @@ using System.Collections.Generic; -namespace MoonSharp.Interpreter.Debugging +namespace WattleScript.Interpreter.Debugging { /// /// Interface for debuggers to implement, in order to provide debugging facilities to Scripts. diff --git a/src/MoonSharp.Interpreter/Debugging/SourceCode.cs b/src/WattleScript.Interpreter/Debugging/SourceCode.cs similarity index 98% rename from src/MoonSharp.Interpreter/Debugging/SourceCode.cs rename to src/WattleScript.Interpreter/Debugging/SourceCode.cs index 797db448..6a9930ee 100644 --- a/src/MoonSharp.Interpreter/Debugging/SourceCode.cs +++ b/src/WattleScript.Interpreter/Debugging/SourceCode.cs @@ -2,7 +2,7 @@ using System.Collections.Generic; using System.Text; -namespace MoonSharp.Interpreter.Debugging +namespace WattleScript.Interpreter.Debugging { /// /// Class representing the source code of a given script diff --git a/src/MoonSharp.Interpreter/Debugging/SourceRef.cs b/src/WattleScript.Interpreter/Debugging/SourceRef.cs similarity index 98% rename from src/MoonSharp.Interpreter/Debugging/SourceRef.cs rename to src/WattleScript.Interpreter/Debugging/SourceRef.cs index 9c33e52e..dead86d8 100755 --- a/src/MoonSharp.Interpreter/Debugging/SourceRef.cs +++ b/src/WattleScript.Interpreter/Debugging/SourceRef.cs @@ -1,7 +1,7 @@ using System; -using MoonSharp.Interpreter.IO; +using WattleScript.Interpreter.IO; -namespace MoonSharp.Interpreter.Debugging +namespace WattleScript.Interpreter.Debugging { /// /// Class representing a reference to source code interval diff --git a/src/MoonSharp.Interpreter/Debugging/WatchItem.cs b/src/WattleScript.Interpreter/Debugging/WatchItem.cs similarity index 97% rename from src/MoonSharp.Interpreter/Debugging/WatchItem.cs rename to src/WattleScript.Interpreter/Debugging/WatchItem.cs index d0210af9..f46d43df 100644 --- a/src/MoonSharp.Interpreter/Debugging/WatchItem.cs +++ b/src/WattleScript.Interpreter/Debugging/WatchItem.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Debugging +namespace WattleScript.Interpreter.Debugging { /// /// A watch item for the debugger to consume. diff --git a/src/MoonSharp.Interpreter/Debugging/WatchType.cs b/src/WattleScript.Interpreter/Debugging/WatchType.cs similarity index 93% rename from src/MoonSharp.Interpreter/Debugging/WatchType.cs rename to src/WattleScript.Interpreter/Debugging/WatchType.cs index 85930208..8de34810 100644 --- a/src/MoonSharp.Interpreter/Debugging/WatchType.cs +++ b/src/WattleScript.Interpreter/Debugging/WatchType.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Debugging +namespace WattleScript.Interpreter.Debugging { /// /// Enumeration of the possible watch types diff --git a/src/MoonSharp.Interpreter/Diagnostics/PerformanceCounter.cs b/src/WattleScript.Interpreter/Diagnostics/PerformanceCounter.cs similarity index 93% rename from src/MoonSharp.Interpreter/Diagnostics/PerformanceCounter.cs rename to src/WattleScript.Interpreter/Diagnostics/PerformanceCounter.cs index aa182019..6530705d 100644 --- a/src/MoonSharp.Interpreter/Diagnostics/PerformanceCounter.cs +++ b/src/WattleScript.Interpreter/Diagnostics/PerformanceCounter.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Diagnostics +namespace WattleScript.Interpreter.Diagnostics { /// /// Enumeration of the possible performance counters diff --git a/src/MoonSharp.Interpreter/Diagnostics/PerformanceCounterType.cs b/src/WattleScript.Interpreter/Diagnostics/PerformanceCounterType.cs similarity index 88% rename from src/MoonSharp.Interpreter/Diagnostics/PerformanceCounterType.cs rename to src/WattleScript.Interpreter/Diagnostics/PerformanceCounterType.cs index 9b427d41..9f2b623a 100644 --- a/src/MoonSharp.Interpreter/Diagnostics/PerformanceCounterType.cs +++ b/src/WattleScript.Interpreter/Diagnostics/PerformanceCounterType.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Diagnostics +namespace WattleScript.Interpreter.Diagnostics { /// /// Enumeration of unit of measures of the performance counters diff --git a/src/MoonSharp.Interpreter/Diagnostics/PerformanceCounters/DummyPerformanceStopwatch.cs b/src/WattleScript.Interpreter/Diagnostics/PerformanceCounters/DummyPerformanceStopwatch.cs similarity index 89% rename from src/MoonSharp.Interpreter/Diagnostics/PerformanceCounters/DummyPerformanceStopwatch.cs rename to src/WattleScript.Interpreter/Diagnostics/PerformanceCounters/DummyPerformanceStopwatch.cs index 896b74fc..bdcd18e6 100644 --- a/src/MoonSharp.Interpreter/Diagnostics/PerformanceCounters/DummyPerformanceStopwatch.cs +++ b/src/WattleScript.Interpreter/Diagnostics/PerformanceCounters/DummyPerformanceStopwatch.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Diagnostics.PerformanceCounters +namespace WattleScript.Interpreter.Diagnostics.PerformanceCounters { class DummyPerformanceStopwatch : IPerformanceStopwatch, IDisposable { diff --git a/src/MoonSharp.Interpreter/Diagnostics/PerformanceCounters/GlobalPerformanceStopwatch.cs b/src/WattleScript.Interpreter/Diagnostics/PerformanceCounters/GlobalPerformanceStopwatch.cs similarity index 95% rename from src/MoonSharp.Interpreter/Diagnostics/PerformanceCounters/GlobalPerformanceStopwatch.cs rename to src/WattleScript.Interpreter/Diagnostics/PerformanceCounters/GlobalPerformanceStopwatch.cs index a3b13278..4264f84d 100644 --- a/src/MoonSharp.Interpreter/Diagnostics/PerformanceCounters/GlobalPerformanceStopwatch.cs +++ b/src/WattleScript.Interpreter/Diagnostics/PerformanceCounters/GlobalPerformanceStopwatch.cs @@ -1,7 +1,7 @@ using System; using System.Diagnostics; -namespace MoonSharp.Interpreter.Diagnostics.PerformanceCounters +namespace WattleScript.Interpreter.Diagnostics.PerformanceCounters { /// /// This class is not *really* IDisposable.. it's just use to have a RAII like pattern. diff --git a/src/MoonSharp.Interpreter/Diagnostics/PerformanceCounters/IPerformanceStopwatch.cs b/src/WattleScript.Interpreter/Diagnostics/PerformanceCounters/IPerformanceStopwatch.cs similarity index 65% rename from src/MoonSharp.Interpreter/Diagnostics/PerformanceCounters/IPerformanceStopwatch.cs rename to src/WattleScript.Interpreter/Diagnostics/PerformanceCounters/IPerformanceStopwatch.cs index 16ab7c0b..d6f8bab1 100644 --- a/src/MoonSharp.Interpreter/Diagnostics/PerformanceCounters/IPerformanceStopwatch.cs +++ b/src/WattleScript.Interpreter/Diagnostics/PerformanceCounters/IPerformanceStopwatch.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Diagnostics.PerformanceCounters +namespace WattleScript.Interpreter.Diagnostics.PerformanceCounters { internal interface IPerformanceStopwatch { diff --git a/src/MoonSharp.Interpreter/Diagnostics/PerformanceCounters/PerformanceStopwatch.cs b/src/WattleScript.Interpreter/Diagnostics/PerformanceCounters/PerformanceStopwatch.cs similarity index 94% rename from src/MoonSharp.Interpreter/Diagnostics/PerformanceCounters/PerformanceStopwatch.cs rename to src/WattleScript.Interpreter/Diagnostics/PerformanceCounters/PerformanceStopwatch.cs index 97b956cb..edc68266 100644 --- a/src/MoonSharp.Interpreter/Diagnostics/PerformanceCounters/PerformanceStopwatch.cs +++ b/src/WattleScript.Interpreter/Diagnostics/PerformanceCounters/PerformanceStopwatch.cs @@ -1,7 +1,7 @@ using System; using System.Diagnostics; -namespace MoonSharp.Interpreter.Diagnostics.PerformanceCounters +namespace WattleScript.Interpreter.Diagnostics.PerformanceCounters { /// /// This class is not *really* IDisposable.. it's just use to have a RAII like pattern. diff --git a/src/MoonSharp.Interpreter/Diagnostics/PerformanceResult.cs b/src/WattleScript.Interpreter/Diagnostics/PerformanceResult.cs similarity index 97% rename from src/MoonSharp.Interpreter/Diagnostics/PerformanceResult.cs rename to src/WattleScript.Interpreter/Diagnostics/PerformanceResult.cs index 2d278715..be16c3ec 100644 --- a/src/MoonSharp.Interpreter/Diagnostics/PerformanceResult.cs +++ b/src/WattleScript.Interpreter/Diagnostics/PerformanceResult.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Diagnostics +namespace WattleScript.Interpreter.Diagnostics { /// /// The result of a performance counter diff --git a/src/MoonSharp.Interpreter/Diagnostics/PerformanceStatistics.cs b/src/WattleScript.Interpreter/Diagnostics/PerformanceStatistics.cs similarity index 96% rename from src/MoonSharp.Interpreter/Diagnostics/PerformanceStatistics.cs rename to src/WattleScript.Interpreter/Diagnostics/PerformanceStatistics.cs index c4de85cf..1be1f55f 100644 --- a/src/MoonSharp.Interpreter/Diagnostics/PerformanceStatistics.cs +++ b/src/WattleScript.Interpreter/Diagnostics/PerformanceStatistics.cs @@ -1,8 +1,8 @@ using System; using System.Text; -using MoonSharp.Interpreter.Diagnostics.PerformanceCounters; +using WattleScript.Interpreter.Diagnostics.PerformanceCounters; -namespace MoonSharp.Interpreter.Diagnostics +namespace WattleScript.Interpreter.Diagnostics { /// /// A single object of this type exists for every script and gives access to performance statistics. diff --git a/src/MoonSharp.Interpreter/Errors/DynamicExpressionException.cs b/src/WattleScript.Interpreter/Errors/DynamicExpressionException.cs similarity index 95% rename from src/MoonSharp.Interpreter/Errors/DynamicExpressionException.cs rename to src/WattleScript.Interpreter/Errors/DynamicExpressionException.cs index 3bb68a72..9122fd2e 100755 --- a/src/MoonSharp.Interpreter/Errors/DynamicExpressionException.cs +++ b/src/WattleScript.Interpreter/Errors/DynamicExpressionException.cs @@ -1,7 +1,7 @@  using System; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Exception thrown when a dynamic expression is invalid diff --git a/src/MoonSharp.Interpreter/Errors/InternalErrorException.cs b/src/WattleScript.Interpreter/Errors/InternalErrorException.cs similarity index 91% rename from src/MoonSharp.Interpreter/Errors/InternalErrorException.cs rename to src/WattleScript.Interpreter/Errors/InternalErrorException.cs index 29844fef..dc9bf79f 100755 --- a/src/MoonSharp.Interpreter/Errors/InternalErrorException.cs +++ b/src/WattleScript.Interpreter/Errors/InternalErrorException.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Exception thrown when an inconsistent state is reached in the interpreter diff --git a/src/MoonSharp.Interpreter/Errors/InterpreterException.cs b/src/WattleScript.Interpreter/Errors/InterpreterException.cs similarity index 91% rename from src/MoonSharp.Interpreter/Errors/InterpreterException.cs rename to src/WattleScript.Interpreter/Errors/InterpreterException.cs index 8ba05340..0a8ee9ec 100755 --- a/src/MoonSharp.Interpreter/Errors/InterpreterException.cs +++ b/src/WattleScript.Interpreter/Errors/InterpreterException.cs @@ -1,11 +1,11 @@ using System; using System.Collections.Generic; -using MoonSharp.Interpreter.Debugging; +using WattleScript.Interpreter.Debugging; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// - /// Base type of all exceptions thrown in MoonSharp + /// Base type of all exceptions thrown in WattleScript /// [Serializable] public class InterpreterException : Exception @@ -59,7 +59,7 @@ protected InterpreterException(string format, params object[] args) /// /// Gets the interpreter call stack. /// - public IList CallStack { get; internal set; } + public IList CallStack { get; internal set; } /// /// Gets the decorated message (error message plus error location in script) if possible. diff --git a/src/MoonSharp.Interpreter/Errors/ScriptRuntimeException.cs b/src/WattleScript.Interpreter/Errors/ScriptRuntimeException.cs similarity index 98% rename from src/MoonSharp.Interpreter/Errors/ScriptRuntimeException.cs rename to src/WattleScript.Interpreter/Errors/ScriptRuntimeException.cs index ac240f75..ea258d8d 100755 --- a/src/MoonSharp.Interpreter/Errors/ScriptRuntimeException.cs +++ b/src/WattleScript.Interpreter/Errors/ScriptRuntimeException.cs @@ -1,8 +1,8 @@ using System; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Interop.BasicDescriptors; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Exception for all runtime errors. In addition to constructors, it offers a lot of static methods @@ -405,7 +405,7 @@ public static ScriptRuntimeException ConvertObjectFailed(DataType t, Type t2) /// public static ScriptRuntimeException UserDataArgumentTypeMismatch(DataType t, Type clrType) { - return new ScriptRuntimeException("cannot find a conversion from a MoonSharp {0} to a clr {1}", t.ToString().ToLowerInvariant(), clrType.FullName); + return new ScriptRuntimeException("cannot find a conversion from a WattleScript {0} to a clr {1}", t.ToString().ToLowerInvariant(), clrType.FullName); } /// diff --git a/src/MoonSharp.Interpreter/Errors/SyntaxErrorException.cs b/src/WattleScript.Interpreter/Errors/SyntaxErrorException.cs similarity index 93% rename from src/MoonSharp.Interpreter/Errors/SyntaxErrorException.cs rename to src/WattleScript.Interpreter/Errors/SyntaxErrorException.cs index 7c29d2a7..d1263d37 100755 --- a/src/MoonSharp.Interpreter/Errors/SyntaxErrorException.cs +++ b/src/WattleScript.Interpreter/Errors/SyntaxErrorException.cs @@ -1,8 +1,8 @@ using System; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Tree; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Tree; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Exception for all parsing/lexing errors. diff --git a/src/MoonSharp.Interpreter/Execution/DynamicExpression.cs b/src/WattleScript.Interpreter/Execution/DynamicExpression.cs similarity index 96% rename from src/MoonSharp.Interpreter/Execution/DynamicExpression.cs rename to src/WattleScript.Interpreter/Execution/DynamicExpression.cs index d30bdb0b..7fa0314f 100644 --- a/src/MoonSharp.Interpreter/Execution/DynamicExpression.cs +++ b/src/WattleScript.Interpreter/Execution/DynamicExpression.cs @@ -1,6 +1,6 @@ -using MoonSharp.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Tree.Expressions; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Represents a dynamic expression in the script diff --git a/src/MoonSharp.Interpreter/Execution/InstructionFieldUsage.cs b/src/WattleScript.Interpreter/Execution/InstructionFieldUsage.cs similarity index 97% rename from src/MoonSharp.Interpreter/Execution/InstructionFieldUsage.cs rename to src/WattleScript.Interpreter/Execution/InstructionFieldUsage.cs index 2154bc38..7e930b98 100644 --- a/src/MoonSharp.Interpreter/Execution/InstructionFieldUsage.cs +++ b/src/WattleScript.Interpreter/Execution/InstructionFieldUsage.cs @@ -1,7 +1,7 @@ using System; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Execution +namespace WattleScript.Interpreter.Execution { [Flags] internal enum InstructionFieldUsage diff --git a/src/MoonSharp.Interpreter/Execution/Scopes/BuildTimeScope.cs b/src/WattleScript.Interpreter/Execution/Scopes/BuildTimeScope.cs similarity index 93% rename from src/MoonSharp.Interpreter/Execution/Scopes/BuildTimeScope.cs rename to src/WattleScript.Interpreter/Execution/Scopes/BuildTimeScope.cs index 560e95dd..fa2b3359 100644 --- a/src/MoonSharp.Interpreter/Execution/Scopes/BuildTimeScope.cs +++ b/src/WattleScript.Interpreter/Execution/Scopes/BuildTimeScope.cs @@ -1,10 +1,10 @@ using System.Collections.Generic; using System.Linq; -using MoonSharp.Interpreter.Execution.Scopes; -using MoonSharp.Interpreter.Tree; -using MoonSharp.Interpreter.Tree.Statements; +using WattleScript.Interpreter.Execution.Scopes; +using WattleScript.Interpreter.Tree; +using WattleScript.Interpreter.Tree.Statements; -namespace MoonSharp.Interpreter.Execution +namespace WattleScript.Interpreter.Execution { internal class BuildTimeScope { diff --git a/src/MoonSharp.Interpreter/Execution/Scopes/BuildTimeScopeBlock.cs b/src/WattleScript.Interpreter/Execution/Scopes/BuildTimeScopeBlock.cs similarity index 97% rename from src/MoonSharp.Interpreter/Execution/Scopes/BuildTimeScopeBlock.cs rename to src/WattleScript.Interpreter/Execution/Scopes/BuildTimeScopeBlock.cs index ac5b91b6..ef19a841 100644 --- a/src/MoonSharp.Interpreter/Execution/Scopes/BuildTimeScopeBlock.cs +++ b/src/WattleScript.Interpreter/Execution/Scopes/BuildTimeScopeBlock.cs @@ -1,9 +1,9 @@ using System; using System.Collections.Generic; using System.Linq; -using MoonSharp.Interpreter.Tree.Statements; +using WattleScript.Interpreter.Tree.Statements; -namespace MoonSharp.Interpreter.Execution.Scopes +namespace WattleScript.Interpreter.Execution.Scopes { internal class BuildTimeScopeBlock { diff --git a/src/MoonSharp.Interpreter/Execution/Scopes/BuildTimeScopeFrame.cs b/src/WattleScript.Interpreter/Execution/Scopes/BuildTimeScopeFrame.cs similarity index 95% rename from src/MoonSharp.Interpreter/Execution/Scopes/BuildTimeScopeFrame.cs rename to src/WattleScript.Interpreter/Execution/Scopes/BuildTimeScopeFrame.cs index 94c96561..126c6b5f 100644 --- a/src/MoonSharp.Interpreter/Execution/Scopes/BuildTimeScopeFrame.cs +++ b/src/WattleScript.Interpreter/Execution/Scopes/BuildTimeScopeFrame.cs @@ -1,8 +1,8 @@ using System.Collections.Generic; using System.Linq; -using MoonSharp.Interpreter.Tree.Statements; +using WattleScript.Interpreter.Tree.Statements; -namespace MoonSharp.Interpreter.Execution.Scopes +namespace WattleScript.Interpreter.Execution.Scopes { internal class BuildTimeScopeFrame { diff --git a/src/MoonSharp.Interpreter/Execution/Scopes/ClosureContext.cs b/src/WattleScript.Interpreter/Execution/Scopes/ClosureContext.cs similarity index 92% rename from src/MoonSharp.Interpreter/Execution/Scopes/ClosureContext.cs rename to src/WattleScript.Interpreter/Execution/Scopes/ClosureContext.cs index 2bcc542e..ec20c64a 100644 --- a/src/MoonSharp.Interpreter/Execution/Scopes/ClosureContext.cs +++ b/src/WattleScript.Interpreter/Execution/Scopes/ClosureContext.cs @@ -1,7 +1,7 @@ using System.Collections.Generic; using System.Linq; -namespace MoonSharp.Interpreter.Execution +namespace WattleScript.Interpreter.Execution { /// /// The scope of a closure (container of upvalues) diff --git a/src/MoonSharp.Interpreter/Execution/Scopes/IClosureBuilder.cs b/src/WattleScript.Interpreter/Execution/Scopes/IClosureBuilder.cs similarity index 72% rename from src/MoonSharp.Interpreter/Execution/Scopes/IClosureBuilder.cs rename to src/WattleScript.Interpreter/Execution/Scopes/IClosureBuilder.cs index e13b3b97..b6b05b88 100644 --- a/src/MoonSharp.Interpreter/Execution/Scopes/IClosureBuilder.cs +++ b/src/WattleScript.Interpreter/Execution/Scopes/IClosureBuilder.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Execution +namespace WattleScript.Interpreter.Execution { internal interface IClosureBuilder { diff --git a/src/MoonSharp.Interpreter/Execution/Scopes/LoopTracker.cs b/src/WattleScript.Interpreter/Execution/Scopes/LoopTracker.cs similarity index 61% rename from src/MoonSharp.Interpreter/Execution/Scopes/LoopTracker.cs rename to src/WattleScript.Interpreter/Execution/Scopes/LoopTracker.cs index 40297ea9..4e9735c5 100644 --- a/src/MoonSharp.Interpreter/Execution/Scopes/LoopTracker.cs +++ b/src/WattleScript.Interpreter/Execution/Scopes/LoopTracker.cs @@ -1,7 +1,7 @@ -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Execution +namespace WattleScript.Interpreter.Execution { interface ILoop { diff --git a/src/MoonSharp.Interpreter/Execution/Scopes/RuntimeScopeBlock.cs b/src/WattleScript.Interpreter/Execution/Scopes/RuntimeScopeBlock.cs similarity index 87% rename from src/MoonSharp.Interpreter/Execution/Scopes/RuntimeScopeBlock.cs rename to src/WattleScript.Interpreter/Execution/Scopes/RuntimeScopeBlock.cs index 46dca397..2388db28 100644 --- a/src/MoonSharp.Interpreter/Execution/Scopes/RuntimeScopeBlock.cs +++ b/src/WattleScript.Interpreter/Execution/Scopes/RuntimeScopeBlock.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Execution +namespace WattleScript.Interpreter.Execution { internal class RuntimeScopeBlock { diff --git a/src/MoonSharp.Interpreter/Execution/Scopes/RuntimeScopeFrame.cs b/src/WattleScript.Interpreter/Execution/Scopes/RuntimeScopeFrame.cs similarity index 90% rename from src/MoonSharp.Interpreter/Execution/Scopes/RuntimeScopeFrame.cs rename to src/WattleScript.Interpreter/Execution/Scopes/RuntimeScopeFrame.cs index 0738dc3b..14f4568c 100644 --- a/src/MoonSharp.Interpreter/Execution/Scopes/RuntimeScopeFrame.cs +++ b/src/WattleScript.Interpreter/Execution/Scopes/RuntimeScopeFrame.cs @@ -1,6 +1,6 @@ using System.Collections.Generic; -namespace MoonSharp.Interpreter.Execution +namespace WattleScript.Interpreter.Execution { internal class RuntimeScopeFrame { diff --git a/src/MoonSharp.Interpreter/Execution/Scopes/Upvalue.cs b/src/WattleScript.Interpreter/Execution/Scopes/Upvalue.cs similarity index 92% rename from src/MoonSharp.Interpreter/Execution/Scopes/Upvalue.cs rename to src/WattleScript.Interpreter/Execution/Scopes/Upvalue.cs index 2f9be9c1..10569d1e 100644 --- a/src/MoonSharp.Interpreter/Execution/Scopes/Upvalue.cs +++ b/src/WattleScript.Interpreter/Execution/Scopes/Upvalue.cs @@ -1,7 +1,7 @@ using System.Threading; -using MoonSharp.Interpreter.DataStructs; +using WattleScript.Interpreter.DataStructs; -namespace MoonSharp.Interpreter.Execution +namespace WattleScript.Interpreter.Execution { /// /// Holds a reference to a local in another function diff --git a/src/MoonSharp.Interpreter/Execution/ScriptExecutionContext.cs b/src/WattleScript.Interpreter/Execution/ScriptExecutionContext.cs similarity index 97% rename from src/MoonSharp.Interpreter/Execution/ScriptExecutionContext.cs rename to src/WattleScript.Interpreter/Execution/ScriptExecutionContext.cs index d2286188..c2523cce 100644 --- a/src/MoonSharp.Interpreter/Execution/ScriptExecutionContext.cs +++ b/src/WattleScript.Interpreter/Execution/ScriptExecutionContext.cs @@ -1,9 +1,9 @@ using System; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution.VM; -using MoonSharp.Interpreter.Interop.LuaStateInterop; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution.VM; +using WattleScript.Interpreter.Interop.LuaStateInterop; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Class giving access to details of the environment where the script is executing diff --git a/src/MoonSharp.Interpreter/Execution/ScriptLoadingContext.cs b/src/WattleScript.Interpreter/Execution/ScriptLoadingContext.cs similarity index 83% rename from src/MoonSharp.Interpreter/Execution/ScriptLoadingContext.cs rename to src/WattleScript.Interpreter/Execution/ScriptLoadingContext.cs index 4800a0c0..a0543647 100644 --- a/src/MoonSharp.Interpreter/Execution/ScriptLoadingContext.cs +++ b/src/WattleScript.Interpreter/Execution/ScriptLoadingContext.cs @@ -1,8 +1,8 @@ using System.Collections.Generic; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Tree; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Tree; -namespace MoonSharp.Interpreter.Execution +namespace WattleScript.Interpreter.Execution { class ScriptLoadingContext { diff --git a/src/MoonSharp.Interpreter/Execution/VM/ByteCode.cs b/src/WattleScript.Interpreter/Execution/VM/ByteCode.cs similarity index 99% rename from src/MoonSharp.Interpreter/Execution/VM/ByteCode.cs rename to src/WattleScript.Interpreter/Execution/VM/ByteCode.cs index 1f332f0a..459a412b 100755 --- a/src/MoonSharp.Interpreter/Execution/VM/ByteCode.cs +++ b/src/WattleScript.Interpreter/Execution/VM/ByteCode.cs @@ -5,9 +5,9 @@ using System.Diagnostics; using System.IO; using System.Text; -using MoonSharp.Interpreter.Debugging; +using WattleScript.Interpreter.Debugging; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { internal class ByteCode : RefIdObject { diff --git a/src/MoonSharp.Interpreter/Execution/VM/CallStackItem.cs b/src/WattleScript.Interpreter/Execution/VM/CallStackItem.cs similarity index 87% rename from src/MoonSharp.Interpreter/Execution/VM/CallStackItem.cs rename to src/WattleScript.Interpreter/Execution/VM/CallStackItem.cs index 4262d132..df2258ae 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/CallStackItem.cs +++ b/src/WattleScript.Interpreter/Execution/VM/CallStackItem.cs @@ -1,7 +1,7 @@ using System.Collections.Generic; -using MoonSharp.Interpreter.Debugging; +using WattleScript.Interpreter.Debugging; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { internal struct CallStackItem { diff --git a/src/MoonSharp.Interpreter/Execution/VM/CallStackItemFlags.cs b/src/WattleScript.Interpreter/Execution/VM/CallStackItemFlags.cs similarity index 79% rename from src/MoonSharp.Interpreter/Execution/VM/CallStackItemFlags.cs rename to src/WattleScript.Interpreter/Execution/VM/CallStackItemFlags.cs index 9e6d6eae..138beab3 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/CallStackItemFlags.cs +++ b/src/WattleScript.Interpreter/Execution/VM/CallStackItemFlags.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { [Flags] internal enum CallStackItemFlags diff --git a/src/MoonSharp.Interpreter/Execution/VM/ExecutionState.cs b/src/WattleScript.Interpreter/Execution/VM/ExecutionState.cs similarity index 76% rename from src/MoonSharp.Interpreter/Execution/VM/ExecutionState.cs rename to src/WattleScript.Interpreter/Execution/VM/ExecutionState.cs index 412a0902..2fbbe26f 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/ExecutionState.cs +++ b/src/WattleScript.Interpreter/Execution/VM/ExecutionState.cs @@ -1,6 +1,6 @@ -using MoonSharp.Interpreter.DataStructs; +using WattleScript.Interpreter.DataStructs; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { internal sealed class ExecutionState { diff --git a/src/MoonSharp.Interpreter/Execution/VM/Instruction.cs b/src/WattleScript.Interpreter/Execution/VM/Instruction.cs similarity index 98% rename from src/MoonSharp.Interpreter/Execution/VM/Instruction.cs rename to src/WattleScript.Interpreter/Execution/VM/Instruction.cs index 02f4f16d..2caa0322 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/Instruction.cs +++ b/src/WattleScript.Interpreter/Execution/VM/Instruction.cs @@ -3,11 +3,11 @@ using System.IO; using System.Linq; using System.Runtime.InteropServices; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.IO; -using MoonSharp.Interpreter.Serialization; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.IO; +using WattleScript.Interpreter.Serialization; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { [StructLayout(LayoutKind.Explicit)] internal struct Instruction diff --git a/src/MoonSharp.Interpreter/Execution/VM/OpCode.cs b/src/WattleScript.Interpreter/Execution/VM/OpCode.cs similarity index 91% rename from src/MoonSharp.Interpreter/Execution/VM/OpCode.cs rename to src/WattleScript.Interpreter/Execution/VM/OpCode.cs index 74192e01..0bf343eb 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/OpCode.cs +++ b/src/WattleScript.Interpreter/Execution/VM/OpCode.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { internal enum OpCode { @@ -37,7 +37,7 @@ internal enum OpCode Annot, //Injects annotations BeginFn, // Adjusts for start of function, taking in parameters and allocating locals Args, // Takes the arguments passed to a function and sets the appropriate symbols in the local scope - Call, // Calls the function specified on the specified element from the top of the v-stack. If the function is a MoonSharp function, it pushes its numeric value on the v-stack, then pushes the current PC onto the x-stack, enters the function closure and jumps to the function first instruction. If the function is a CLR function, it pops the function value from the v-stack, then invokes the function synchronously and finally pushes the result on the v-stack. + Call, // Calls the function specified on the specified element from the top of the v-stack. If the function is a WattleScript function, it pushes its numeric value on the v-stack, then pushes the current PC onto the x-stack, enters the function closure and jumps to the function first instruction. If the function is a CLR function, it pops the function value from the v-stack, then invokes the function synchronously and finally pushes the result on the v-stack. ThisCall, // Same as call, but the call is a ':' method invocation Ret, // Pops the top n values of the v-stack. Then pops an X value from the v-stack. Then pops X values from the v-stack. Afterwards, it pushes the top n values popped in the first step, pops the top of the x-stack and jumps to that location. diff --git a/src/MoonSharp.Interpreter/Execution/VM/OpCodeMetadataType.cs b/src/WattleScript.Interpreter/Execution/VM/OpCodeMetadataType.cs similarity index 78% rename from src/MoonSharp.Interpreter/Execution/VM/OpCodeMetadataType.cs rename to src/WattleScript.Interpreter/Execution/VM/OpCodeMetadataType.cs index 8b5dd3fd..1c31c077 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/OpCodeMetadataType.cs +++ b/src/WattleScript.Interpreter/Execution/VM/OpCodeMetadataType.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { public enum OpCodeMetadataType { diff --git a/src/MoonSharp.Interpreter/Execution/VM/Processor/DebugContext.cs b/src/WattleScript.Interpreter/Execution/VM/Processor/DebugContext.cs similarity index 85% rename from src/MoonSharp.Interpreter/Execution/VM/Processor/DebugContext.cs rename to src/WattleScript.Interpreter/Execution/VM/Processor/DebugContext.cs index eabe0f9d..aca54d45 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/Processor/DebugContext.cs +++ b/src/WattleScript.Interpreter/Execution/VM/Processor/DebugContext.cs @@ -1,7 +1,7 @@ using System.Collections.Generic; -using MoonSharp.Interpreter.Debugging; +using WattleScript.Interpreter.Debugging; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { sealed partial class Processor { diff --git a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor.cs b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor.cs similarity index 94% rename from src/MoonSharp.Interpreter/Execution/VM/Processor/Processor.cs rename to src/WattleScript.Interpreter/Execution/VM/Processor/Processor.cs index bd736b95..a7c50c0e 100755 --- a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor.cs +++ b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor.cs @@ -2,11 +2,11 @@ using System.Collections.Generic; using System.Threading; using System.Threading.Tasks; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Interop; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { sealed partial class Processor { @@ -186,7 +186,7 @@ private void EnterProcessor() if (m_OwningThreadID >= 0 && m_OwningThreadID != threadID && m_Script.Options.CheckThreadAccess) { - string msg = string.Format("Cannot enter the same MoonSharp processor from two different threads : {0} and {1}", m_OwningThreadID, threadID); + string msg = string.Format("Cannot enter the same WattleScript processor from two different threads : {0} and {1}", m_OwningThreadID, threadID); throw new InvalidOperationException(msg); } diff --git a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_BinaryDump.cs b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_BinaryDump.cs similarity index 95% rename from src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_BinaryDump.cs rename to src/WattleScript.Interpreter/Execution/VM/Processor/Processor_BinaryDump.cs index 5ddd7831..6913974b 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_BinaryDump.cs +++ b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_BinaryDump.cs @@ -3,10 +3,10 @@ using System.IO; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.IO; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.IO; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { sealed partial class Processor { @@ -124,7 +124,7 @@ internal int Undump(Stream stream, int sourceID, Table envTable, out bool hasUpv ulong headerMark = br.ReadUInt64(); if (headerMark != DUMP_CHUNK_MAGIC) - throw new ArgumentException("Not a MoonSharp chunk"); + throw new ArgumentException("Not a WattleScript chunk"); int version = br.ReadByte(); diff --git a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_Coroutines.cs b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_Coroutines.cs similarity index 97% rename from src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_Coroutines.cs rename to src/WattleScript.Interpreter/Execution/VM/Processor/Processor_Coroutines.cs index eafecf09..32c9ee62 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_Coroutines.cs +++ b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_Coroutines.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { // This part is practically written procedural style - it looks more like C than C#. // This is intentional so to avoid this-calls and virtual-calls as much as possible. diff --git a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_Debugger.cs b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_Debugger.cs similarity index 99% rename from src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_Debugger.cs rename to src/WattleScript.Interpreter/Execution/VM/Processor/Processor_Debugger.cs index 550d0df3..4c4d0d45 100755 --- a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_Debugger.cs +++ b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_Debugger.cs @@ -1,9 +1,9 @@ using System; using System.Collections.Generic; using System.Linq; -using MoonSharp.Interpreter.Debugging; +using WattleScript.Interpreter.Debugging; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { // This part is practically written procedural style - it looks more like C than C#. // This is intentional so to avoid this-calls and virtual-calls as much as possible. diff --git a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_Errors.cs b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_Errors.cs similarity index 86% rename from src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_Errors.cs rename to src/WattleScript.Interpreter/Execution/VM/Processor/Processor_Errors.cs index dc0e6ddf..ec783302 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_Errors.cs +++ b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_Errors.cs @@ -1,6 +1,6 @@ -using MoonSharp.Interpreter.Debugging; +using WattleScript.Interpreter.Debugging; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { sealed partial class Processor { diff --git a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_IExecutionContext.cs b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_IExecutionContext.cs similarity index 97% rename from src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_IExecutionContext.cs rename to src/WattleScript.Interpreter/Execution/VM/Processor/Processor_IExecutionContext.cs index 0417adb4..c28d5841 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_IExecutionContext.cs +++ b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_IExecutionContext.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { sealed partial class Processor { diff --git a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_InstructionLoop.cs b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_InstructionLoop.cs similarity index 99% rename from src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_InstructionLoop.cs rename to src/WattleScript.Interpreter/Execution/VM/Processor/Processor_InstructionLoop.cs index 6d8e608f..41615d45 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_InstructionLoop.cs +++ b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_InstructionLoop.cs @@ -2,11 +2,11 @@ using System.Collections.Generic; using System.Globalization; using System.Linq; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Interop; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { sealed partial class Processor { @@ -567,7 +567,7 @@ private void ExecIterPrep(Instruction i) DynValue s = v.Tuple.Length >= 2 ? v.Tuple[1] : DynValue.Nil; DynValue var = v.Tuple.Length >= 3 ? v.Tuple[2] : DynValue.Nil; - // MoonSharp additions - given f, s, var + // WattleScript additions - given f, s, var // 1) if f is not a function and has a __iterator metamethod, call __iterator to get the triplet // 2) if f is a table with no __call metamethod, use a default table iterator diff --git a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_Scope.cs b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_Scope.cs similarity index 98% rename from src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_Scope.cs rename to src/WattleScript.Interpreter/Execution/VM/Processor/Processor_Scope.cs index 3e2c0dcb..0ae4f989 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_Scope.cs +++ b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_Scope.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { sealed partial class Processor { diff --git a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_UtilityFunctions.cs b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_UtilityFunctions.cs similarity index 98% rename from src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_UtilityFunctions.cs rename to src/WattleScript.Interpreter/Execution/VM/Processor/Processor_UtilityFunctions.cs index 880a8b58..cffc9d77 100644 --- a/src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_UtilityFunctions.cs +++ b/src/WattleScript.Interpreter/Execution/VM/Processor/Processor_UtilityFunctions.cs @@ -1,6 +1,6 @@ using System.Collections.Generic; -namespace MoonSharp.Interpreter.Execution.VM +namespace WattleScript.Interpreter.Execution.VM { sealed partial class Processor { diff --git a/src/MoonSharp.Interpreter/IAnnotationPolicy.cs b/src/WattleScript.Interpreter/IAnnotationPolicy.cs similarity index 98% rename from src/MoonSharp.Interpreter/IAnnotationPolicy.cs rename to src/WattleScript.Interpreter/IAnnotationPolicy.cs index d01fddbb..8833d038 100644 --- a/src/MoonSharp.Interpreter/IAnnotationPolicy.cs +++ b/src/WattleScript.Interpreter/IAnnotationPolicy.cs @@ -1,4 +1,4 @@ -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { public enum AnnotationValueParsingPolicy { diff --git a/src/MoonSharp.Interpreter/IO/BinDumpReader.cs b/src/WattleScript.Interpreter/IO/BinDumpReader.cs similarity index 98% rename from src/MoonSharp.Interpreter/IO/BinDumpReader.cs rename to src/WattleScript.Interpreter/IO/BinDumpReader.cs index dfa70135..42d7f5a8 100755 --- a/src/MoonSharp.Interpreter/IO/BinDumpReader.cs +++ b/src/WattleScript.Interpreter/IO/BinDumpReader.cs @@ -3,7 +3,7 @@ using System.IO; using System.Text; -namespace MoonSharp.Interpreter.IO +namespace WattleScript.Interpreter.IO { /// /// "Optimized" BinaryReader which shares strings and use a dumb compression for integers diff --git a/src/MoonSharp.Interpreter/IO/BinDumpWriter.cs b/src/WattleScript.Interpreter/IO/BinDumpWriter.cs similarity index 98% rename from src/MoonSharp.Interpreter/IO/BinDumpWriter.cs rename to src/WattleScript.Interpreter/IO/BinDumpWriter.cs index f1e36fa7..8f17bb58 100755 --- a/src/MoonSharp.Interpreter/IO/BinDumpWriter.cs +++ b/src/WattleScript.Interpreter/IO/BinDumpWriter.cs @@ -4,7 +4,7 @@ using System.Security.Cryptography; using System.Text; -namespace MoonSharp.Interpreter.IO +namespace WattleScript.Interpreter.IO { /// /// "Optimized" BinaryWriter which shares strings and use a dumb compression for integers diff --git a/src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpHiddenAttribute.cs b/src/WattleScript.Interpreter/Interop/Attributes/MoonSharpHiddenAttribute.cs similarity index 66% rename from src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpHiddenAttribute.cs rename to src/WattleScript.Interpreter/Interop/Attributes/MoonSharpHiddenAttribute.cs index 7012483d..fb871231 100644 --- a/src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpHiddenAttribute.cs +++ b/src/WattleScript.Interpreter/Interop/Attributes/MoonSharpHiddenAttribute.cs @@ -1,13 +1,13 @@ using System; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// - /// Forces a class member visibility to scripts. Can be used to hide public members. Equivalent to MoonSharpVisible(false). + /// Forces a class member visibility to scripts. Can be used to hide public members. Equivalent to WattleScriptVisible(false). /// [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Constructor | AttributeTargets.Event, Inherited = true, AllowMultiple = false)] - public sealed class MoonSharpHiddenAttribute : Attribute + public sealed class WattleScriptHiddenAttribute : Attribute { } } diff --git a/src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpHideMemberAttribute.cs b/src/WattleScript.Interpreter/Interop/Attributes/MoonSharpHideMemberAttribute.cs similarity index 67% rename from src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpHideMemberAttribute.cs rename to src/WattleScript.Interpreter/Interop/Attributes/MoonSharpHideMemberAttribute.cs index cc5df024..491680ac 100644 --- a/src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpHideMemberAttribute.cs +++ b/src/WattleScript.Interpreter/Interop/Attributes/MoonSharpHideMemberAttribute.cs @@ -1,12 +1,12 @@ using System; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Lists a userdata member not to be exposed to scripts referencing it by name. /// [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = true, AllowMultiple = true)] - public sealed class MoonSharpHideMemberAttribute : Attribute + public sealed class WattleScriptHideMemberAttribute : Attribute { /// /// Gets the name of the member to be hidden. @@ -14,10 +14,10 @@ public sealed class MoonSharpHideMemberAttribute : Attribute public string MemberName { get; private set; } /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// Name of the member to hide. - public MoonSharpHideMemberAttribute(string memberName) + public WattleScriptHideMemberAttribute(string memberName) { MemberName = memberName; } diff --git a/src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpPropertyAttribute.cs b/src/WattleScript.Interpreter/Interop/Attributes/MoonSharpPropertyAttribute.cs similarity index 56% rename from src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpPropertyAttribute.cs rename to src/WattleScript.Interpreter/Interop/Attributes/MoonSharpPropertyAttribute.cs index a3fe6fec..5c7dc8d4 100644 --- a/src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpPropertyAttribute.cs +++ b/src/WattleScript.Interpreter/Interop/Attributes/MoonSharpPropertyAttribute.cs @@ -1,13 +1,13 @@ using System; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Marks a property as a configruation property /// [AttributeUsage(AttributeTargets.Property, Inherited = true, AllowMultiple = true)] - public sealed class MoonSharpPropertyAttribute : Attribute + public sealed class WattleScriptPropertyAttribute : Attribute { /// /// The metamethod name (like '__div', '__ipairs', etc.) @@ -16,18 +16,18 @@ public sealed class MoonSharpPropertyAttribute : Attribute /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// - public MoonSharpPropertyAttribute() + public WattleScriptPropertyAttribute() { } /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// The name for this property - public MoonSharpPropertyAttribute(string name) + public WattleScriptPropertyAttribute(string name) { Name = name; } diff --git a/src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpUserDataAttribute.cs b/src/WattleScript.Interpreter/Interop/Attributes/MoonSharpUserDataAttribute.cs similarity index 67% rename from src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpUserDataAttribute.cs rename to src/WattleScript.Interpreter/Interop/Attributes/MoonSharpUserDataAttribute.cs index ec2c5c64..67f23ebb 100644 --- a/src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpUserDataAttribute.cs +++ b/src/WattleScript.Interpreter/Interop/Attributes/MoonSharpUserDataAttribute.cs @@ -1,12 +1,12 @@ using System; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Marks a type of automatic registration as userdata (which happens only if UserData.RegisterAssembly is called). /// [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false, AllowMultiple = false)] - public sealed class MoonSharpUserDataAttribute : Attribute + public sealed class WattleScriptUserDataAttribute : Attribute { /// /// The interop access mode @@ -14,9 +14,9 @@ public sealed class MoonSharpUserDataAttribute : Attribute public InteropAccessMode AccessMode { get; set; } /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// - public MoonSharpUserDataAttribute() + public WattleScriptUserDataAttribute() { AccessMode = InteropAccessMode.Default; } diff --git a/src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpUserDataMetamethodAttribute.cs b/src/WattleScript.Interpreter/Interop/Attributes/MoonSharpUserDataMetamethodAttribute.cs similarity index 64% rename from src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpUserDataMetamethodAttribute.cs rename to src/WattleScript.Interpreter/Interop/Attributes/MoonSharpUserDataMetamethodAttribute.cs index 42fb93ba..cbee70bb 100644 --- a/src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpUserDataMetamethodAttribute.cs +++ b/src/WattleScript.Interpreter/Interop/Attributes/MoonSharpUserDataMetamethodAttribute.cs @@ -1,12 +1,12 @@ using System; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Marks a method as the handler of metamethods of a userdata type /// [AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = true)] - public sealed class MoonSharpUserDataMetamethodAttribute : Attribute + public sealed class WattleScriptUserDataMetamethodAttribute : Attribute { /// /// The metamethod name (like '__div', '__ipairs', etc.) @@ -14,10 +14,10 @@ public sealed class MoonSharpUserDataMetamethodAttribute : Attribute public string Name { get; private set; } /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// The metamethod name (like '__div', '__ipairs', etc.) - public MoonSharpUserDataMetamethodAttribute(string name) + public WattleScriptUserDataMetamethodAttribute(string name) { Name = name; } diff --git a/src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpVisibleAttribute.cs b/src/WattleScript.Interpreter/Interop/Attributes/MoonSharpVisibleAttribute.cs similarity index 64% rename from src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpVisibleAttribute.cs rename to src/WattleScript.Interpreter/Interop/Attributes/MoonSharpVisibleAttribute.cs index 03b43369..0790e5f6 100644 --- a/src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpVisibleAttribute.cs +++ b/src/WattleScript.Interpreter/Interop/Attributes/MoonSharpVisibleAttribute.cs @@ -1,24 +1,24 @@ using System; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Forces a class member visibility to scripts. Can be used to hide public members or to expose non-public ones. /// [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Constructor | AttributeTargets.Event, Inherited = true, AllowMultiple = false)] - public sealed class MoonSharpVisibleAttribute : Attribute + public sealed class WattleScriptVisibleAttribute : Attribute { /// - /// Gets a value indicating whether this is set to "visible". + /// Gets a value indicating whether this is set to "visible". /// public bool Visible { get; private set; } /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// if set to true the member will be exposed to scripts, if false the member will be hidden. - public MoonSharpVisibleAttribute(bool visible) + public WattleScriptVisibleAttribute(bool visible) { Visible = visible; } diff --git a/src/MoonSharp.Interpreter/Interop/BasicDescriptors/DispatchingUserDataDescriptor.cs b/src/WattleScript.Interpreter/Interop/BasicDescriptors/DispatchingUserDataDescriptor.cs similarity index 99% rename from src/MoonSharp.Interpreter/Interop/BasicDescriptors/DispatchingUserDataDescriptor.cs rename to src/WattleScript.Interpreter/Interop/BasicDescriptors/DispatchingUserDataDescriptor.cs index 85cb81f3..abc8d215 100644 --- a/src/MoonSharp.Interpreter/Interop/BasicDescriptors/DispatchingUserDataDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/BasicDescriptors/DispatchingUserDataDescriptor.cs @@ -1,9 +1,9 @@ using System; using System.Collections.Generic; using System.Linq; -using MoonSharp.Interpreter.Interop.Converters; +using WattleScript.Interpreter.Interop.Converters; -namespace MoonSharp.Interpreter.Interop.BasicDescriptors +namespace WattleScript.Interpreter.Interop.BasicDescriptors { /// /// An abstract user data descriptor which accepts members described by objects and @@ -471,7 +471,7 @@ protected virtual DynValue ExecuteIndexer(IMemberDescriptor mdesc, Script script /// it should return "null" (not a nil). /// See for further details. /// - /// If a method exists marked with for the specific + /// If a method exists marked with for the specific /// metamethod requested, that method is returned. /// /// If the above fails, the following dispatching occur: diff --git a/src/MoonSharp.Interpreter/Interop/BasicDescriptors/IMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/BasicDescriptors/IMemberDescriptor.cs similarity index 98% rename from src/MoonSharp.Interpreter/Interop/BasicDescriptors/IMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/BasicDescriptors/IMemberDescriptor.cs index 02dacfc7..3d4df51e 100644 --- a/src/MoonSharp.Interpreter/Interop/BasicDescriptors/IMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/BasicDescriptors/IMemberDescriptor.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Interop.BasicDescriptors +namespace WattleScript.Interpreter.Interop.BasicDescriptors { /// /// Base interface to describe access to members of a given type. diff --git a/src/MoonSharp.Interpreter/Interop/BasicDescriptors/IOptimizableDescriptor.cs b/src/WattleScript.Interpreter/Interop/BasicDescriptors/IOptimizableDescriptor.cs similarity index 88% rename from src/MoonSharp.Interpreter/Interop/BasicDescriptors/IOptimizableDescriptor.cs rename to src/WattleScript.Interpreter/Interop/BasicDescriptors/IOptimizableDescriptor.cs index 15edb797..6e92df8d 100644 --- a/src/MoonSharp.Interpreter/Interop/BasicDescriptors/IOptimizableDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/BasicDescriptors/IOptimizableDescriptor.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Interop.BasicDescriptors +namespace WattleScript.Interpreter.Interop.BasicDescriptors { /// /// Interface for descriptors of any kind which support optimizations of their implementation according to InteropAccessMode diff --git a/src/MoonSharp.Interpreter/Interop/BasicDescriptors/IOverloadableMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/BasicDescriptors/IOverloadableMemberDescriptor.cs similarity index 96% rename from src/MoonSharp.Interpreter/Interop/BasicDescriptors/IOverloadableMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/BasicDescriptors/IOverloadableMemberDescriptor.cs index bfd37043..65e06b6f 100644 --- a/src/MoonSharp.Interpreter/Interop/BasicDescriptors/IOverloadableMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/BasicDescriptors/IOverloadableMemberDescriptor.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Interop.BasicDescriptors +namespace WattleScript.Interpreter.Interop.BasicDescriptors { /// /// Specialized for members supporting overloads resolution. diff --git a/src/MoonSharp.Interpreter/Interop/BasicDescriptors/MemberDescriptorAccess.cs b/src/WattleScript.Interpreter/Interop/BasicDescriptors/MemberDescriptorAccess.cs similarity index 86% rename from src/MoonSharp.Interpreter/Interop/BasicDescriptors/MemberDescriptorAccess.cs rename to src/WattleScript.Interpreter/Interop/BasicDescriptors/MemberDescriptorAccess.cs index adbeac67..3b4fcdbe 100644 --- a/src/MoonSharp.Interpreter/Interop/BasicDescriptors/MemberDescriptorAccess.cs +++ b/src/WattleScript.Interpreter/Interop/BasicDescriptors/MemberDescriptorAccess.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Interop.BasicDescriptors +namespace WattleScript.Interpreter.Interop.BasicDescriptors { /// /// Permissions for members access diff --git a/src/MoonSharp.Interpreter/Interop/BasicDescriptors/ParameterDescriptor.cs b/src/WattleScript.Interpreter/Interop/BasicDescriptors/ParameterDescriptor.cs similarity index 99% rename from src/MoonSharp.Interpreter/Interop/BasicDescriptors/ParameterDescriptor.cs rename to src/WattleScript.Interpreter/Interop/BasicDescriptors/ParameterDescriptor.cs index 66f00500..cee2a628 100755 --- a/src/MoonSharp.Interpreter/Interop/BasicDescriptors/ParameterDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/BasicDescriptors/ParameterDescriptor.cs @@ -2,7 +2,7 @@ using System.Linq; using System.Reflection; -namespace MoonSharp.Interpreter.Interop.BasicDescriptors +namespace WattleScript.Interpreter.Interop.BasicDescriptors { /// /// Descriptor of parameters used in implementations. diff --git a/src/MoonSharp.Interpreter/Interop/Converters/ClrToScriptConversions.cs b/src/WattleScript.Interpreter/Interop/Converters/ClrToScriptConversions.cs similarity index 92% rename from src/MoonSharp.Interpreter/Interop/Converters/ClrToScriptConversions.cs rename to src/WattleScript.Interpreter/Interop/Converters/ClrToScriptConversions.cs index 6e279105..0abe6be2 100755 --- a/src/MoonSharp.Interpreter/Interop/Converters/ClrToScriptConversions.cs +++ b/src/WattleScript.Interpreter/Interop/Converters/ClrToScriptConversions.cs @@ -2,14 +2,14 @@ using System.Reflection; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter.Interop.RegistrationPolicies; +using WattleScript.Interpreter.Interop.RegistrationPolicies; -namespace MoonSharp.Interpreter.Interop.Converters +namespace WattleScript.Interpreter.Interop.Converters { internal static class ClrToScriptConversions { /// - /// Tries to convert a CLR object to a MoonSharp value, using "trivial" logic. + /// Tries to convert a CLR object to a WattleScript value, using "trivial" logic. /// Skips on custom conversions, etc. /// Does NOT throw on failure. /// @@ -40,7 +40,7 @@ internal static DynValue TryObjectToTrivialDynValue(Script script, object obj) /// - /// Tries to convert a CLR object to a MoonSharp value, using "simple" logic. + /// Tries to convert a CLR object to a WattleScript value, using "simple" logic. /// Does NOT throw on failure. /// internal static DynValue TryObjectToSimpleDynValue(Script script, object obj) @@ -96,7 +96,7 @@ internal static DynValue TryObjectToSimpleDynValue(Script script, object obj) /// - /// Tries to convert a CLR object to a MoonSharp value, using more in-depth analysis + /// Tries to convert a CLR object to a WattleScript value, using more in-depth analysis /// internal static DynValue ObjectToDynValue(Script script, object obj) { diff --git a/src/MoonSharp.Interpreter/Interop/Converters/NumericConversions.cs b/src/WattleScript.Interpreter/Interop/Converters/NumericConversions.cs similarity index 98% rename from src/MoonSharp.Interpreter/Interop/Converters/NumericConversions.cs rename to src/WattleScript.Interpreter/Interop/Converters/NumericConversions.cs index 14e60efa..ea6ed6fa 100644 --- a/src/MoonSharp.Interpreter/Interop/Converters/NumericConversions.cs +++ b/src/WattleScript.Interpreter/Interop/Converters/NumericConversions.cs @@ -1,7 +1,7 @@ using System; using System.Collections.Generic; -namespace MoonSharp.Interpreter.Interop.Converters +namespace WattleScript.Interpreter.Interop.Converters { /// /// Static functions to handle conversions of numeric types diff --git a/src/MoonSharp.Interpreter/Interop/Converters/ScriptToClrConversions.cs b/src/WattleScript.Interpreter/Interop/Converters/ScriptToClrConversions.cs similarity index 99% rename from src/MoonSharp.Interpreter/Interop/Converters/ScriptToClrConversions.cs rename to src/WattleScript.Interpreter/Interop/Converters/ScriptToClrConversions.cs index 0cd0d3f3..f89fd458 100755 --- a/src/MoonSharp.Interpreter/Interop/Converters/ScriptToClrConversions.cs +++ b/src/WattleScript.Interpreter/Interop/Converters/ScriptToClrConversions.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Interop.Converters +namespace WattleScript.Interpreter.Interop.Converters { internal static class ScriptToClrConversions { diff --git a/src/MoonSharp.Interpreter/Interop/Converters/StringConversions.cs b/src/WattleScript.Interpreter/Interop/Converters/StringConversions.cs similarity index 95% rename from src/MoonSharp.Interpreter/Interop/Converters/StringConversions.cs rename to src/WattleScript.Interpreter/Interop/Converters/StringConversions.cs index f49708a5..0514906b 100644 --- a/src/MoonSharp.Interpreter/Interop/Converters/StringConversions.cs +++ b/src/WattleScript.Interpreter/Interop/Converters/StringConversions.cs @@ -1,7 +1,7 @@ using System; using System.Text; -namespace MoonSharp.Interpreter.Interop.Converters +namespace WattleScript.Interpreter.Interop.Converters { internal static class StringConversions { diff --git a/src/MoonSharp.Interpreter/Interop/Converters/TableConversions.cs b/src/WattleScript.Interpreter/Interop/Converters/TableConversions.cs similarity index 99% rename from src/MoonSharp.Interpreter/Interop/Converters/TableConversions.cs rename to src/WattleScript.Interpreter/Interop/Converters/TableConversions.cs index bf8e1121..626ffa31 100644 --- a/src/MoonSharp.Interpreter/Interop/Converters/TableConversions.cs +++ b/src/WattleScript.Interpreter/Interop/Converters/TableConversions.cs @@ -1,7 +1,7 @@ using System; using System.Collections.Generic; -namespace MoonSharp.Interpreter.Interop.Converters +namespace WattleScript.Interpreter.Interop.Converters { internal static class TableConversions { diff --git a/src/MoonSharp.Interpreter/Interop/CustomConvertersCollection.cs b/src/WattleScript.Interpreter/Interop/CustomConvertersCollection.cs similarity index 98% rename from src/MoonSharp.Interpreter/Interop/CustomConvertersCollection.cs rename to src/WattleScript.Interpreter/Interop/CustomConvertersCollection.cs index 70866ceb..15d542c5 100644 --- a/src/MoonSharp.Interpreter/Interop/CustomConvertersCollection.cs +++ b/src/WattleScript.Interpreter/Interop/CustomConvertersCollection.cs @@ -1,10 +1,10 @@ using System; using System.Collections.Generic; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// - /// A collection of custom converters between MoonSharp types and CLR types. + /// A collection of custom converters between WattleScript types and CLR types. /// If a converter function is not specified or returns null, the standard conversion path applies. /// public class CustomConvertersCollection diff --git a/src/MoonSharp.Interpreter/Interop/DescriptorHelpers.cs b/src/WattleScript.Interpreter/Interop/DescriptorHelpers.cs similarity index 89% rename from src/MoonSharp.Interpreter/Interop/DescriptorHelpers.cs rename to src/WattleScript.Interpreter/Interop/DescriptorHelpers.cs index 07f9f494..6d6bce5b 100755 --- a/src/MoonSharp.Interpreter/Interop/DescriptorHelpers.cs +++ b/src/WattleScript.Interpreter/Interop/DescriptorHelpers.cs @@ -4,7 +4,7 @@ using System.Reflection; using System.Text; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Helper extension methods used to simplify some parts of userdata descriptor implementations @@ -13,7 +13,7 @@ public static class DescriptorHelpers { /// /// Determines whether a - /// or a is changing visibility of a member + /// or a is changing visibility of a member /// to scripts. /// /// The member to check. @@ -22,17 +22,17 @@ public static class DescriptorHelpers /// false if visibility is forced hidden or the specified MemberInfo is null, /// if no attribute was found /// - /// If both MoonSharpHiddenAttribute and MoonSharpVisibleAttribute are specified and they convey different messages. + /// If both WattleScriptHiddenAttribute and WattleScriptVisibleAttribute are specified and they convey different messages. public static bool? GetVisibilityFromAttributes(this MemberInfo mi) { if (mi == null) return false; - MoonSharpVisibleAttribute va = mi.GetCustomAttributes(true).OfType().SingleOrDefault(); - MoonSharpHiddenAttribute ha = mi.GetCustomAttributes(true).OfType().SingleOrDefault(); + WattleScriptVisibleAttribute va = mi.GetCustomAttributes(true).OfType().SingleOrDefault(); + WattleScriptHiddenAttribute ha = mi.GetCustomAttributes(true).OfType().SingleOrDefault(); if (va != null && ha != null && va.Visible) - throw new InvalidOperationException(string.Format("A member ('{0}') can't have discording MoonSharpHiddenAttribute and MoonSharpVisibleAttribute.", mi.Name)); + throw new InvalidOperationException(string.Format("A member ('{0}') can't have discording WattleScriptHiddenAttribute and WattleScriptVisibleAttribute.", mi.Name)); else if (ha != null) return false; else if (va != null) @@ -140,14 +140,14 @@ public static bool IsPropertyInfoPublic(this PropertyInfo pi) /// /// Gets the list of metamethod names from attributes - in practice the list of metamethods declared through - /// . + /// . /// /// The mi. /// public static List GetMetaNamesFromAttributes(this MethodInfo mi) { - return mi.GetCustomAttributes(typeof(MoonSharpUserDataMetamethodAttribute), true) - .OfType() + return mi.GetCustomAttributes(typeof(WattleScriptUserDataMetamethodAttribute), true) + .OfType() .Select(a => a.Name) .ToList(); } diff --git a/src/MoonSharp.Interpreter/Interop/IGeneratorUserDataDescriptor.cs b/src/WattleScript.Interpreter/Interop/IGeneratorUserDataDescriptor.cs similarity index 97% rename from src/MoonSharp.Interpreter/Interop/IGeneratorUserDataDescriptor.cs rename to src/WattleScript.Interpreter/Interop/IGeneratorUserDataDescriptor.cs index 637766a4..7fc14755 100644 --- a/src/MoonSharp.Interpreter/Interop/IGeneratorUserDataDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/IGeneratorUserDataDescriptor.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// An interface for type descriptors having the ability to generate other descriptors on the fly. diff --git a/src/MoonSharp.Interpreter/Interop/IUserDataDescriptor.cs b/src/WattleScript.Interpreter/Interop/IUserDataDescriptor.cs similarity index 95% rename from src/MoonSharp.Interpreter/Interop/IUserDataDescriptor.cs rename to src/WattleScript.Interpreter/Interop/IUserDataDescriptor.cs index b93c8092..63d1962b 100644 --- a/src/MoonSharp.Interpreter/Interop/IUserDataDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/IUserDataDescriptor.cs @@ -1,9 +1,9 @@ using System; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// - /// Interface used by MoonSharp to access objects of a given type from scripts. + /// Interface used by WattleScript to access objects of a given type from scripts. /// public interface IUserDataDescriptor { diff --git a/src/MoonSharp.Interpreter/Interop/IUserDataMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/IUserDataMemberDescriptor.cs similarity index 96% rename from src/MoonSharp.Interpreter/Interop/IUserDataMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/IUserDataMemberDescriptor.cs index 23f83de1..52e2ae2b 100644 --- a/src/MoonSharp.Interpreter/Interop/IUserDataMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/IUserDataMemberDescriptor.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Interface used by standard descriptors to access members of a given type from scripts. diff --git a/src/MoonSharp.Interpreter/Interop/IUserDataType.cs b/src/WattleScript.Interpreter/Interop/IUserDataType.cs similarity index 98% rename from src/MoonSharp.Interpreter/Interop/IUserDataType.cs rename to src/WattleScript.Interpreter/Interop/IUserDataType.cs index 9ae18bbe..ed6a194a 100644 --- a/src/MoonSharp.Interpreter/Interop/IUserDataType.cs +++ b/src/WattleScript.Interpreter/Interop/IUserDataType.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// As a convenience, every type deriving from IUserDataType is "self-described". That is, no descriptor is needed/generated diff --git a/src/MoonSharp.Interpreter/Interop/IWireableDescriptor.cs b/src/WattleScript.Interpreter/Interop/IWireableDescriptor.cs similarity index 88% rename from src/MoonSharp.Interpreter/Interop/IWireableDescriptor.cs rename to src/WattleScript.Interpreter/Interop/IWireableDescriptor.cs index 7bbe8996..4f47f075 100644 --- a/src/MoonSharp.Interpreter/Interop/IWireableDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/IWireableDescriptor.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Interop.BasicDescriptors +namespace WattleScript.Interpreter.Interop.BasicDescriptors { /// /// Interface for descriptors with the capability of being serialized diff --git a/src/MoonSharp.Interpreter/Interop/InteropAccessMode.cs b/src/WattleScript.Interpreter/Interop/InteropAccessMode.cs similarity index 86% rename from src/MoonSharp.Interpreter/Interop/InteropAccessMode.cs rename to src/WattleScript.Interpreter/Interop/InteropAccessMode.cs index 8b5f8b07..5dbf745d 100644 --- a/src/MoonSharp.Interpreter/Interop/InteropAccessMode.cs +++ b/src/WattleScript.Interpreter/Interop/InteropAccessMode.cs @@ -1,10 +1,10 @@  -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// - /// Enumerations of the possible strategies to marshal CLR objects to MoonSharp userdata and functions + /// Enumerations of the possible strategies to marshal CLR objects to WattleScript userdata and functions /// when using automatic descriptors. - /// Note that these are "hints" and MoonSharp is free to ignore the access mode specified (if different from + /// Note that these are "hints" and WattleScript is free to ignore the access mode specified (if different from /// HideMembers) and downgrade the access mode to "Reflection". /// This particularly happens when running on AOT platforms like iOS. /// See also : and . @@ -40,7 +40,7 @@ public enum InteropAccessMode HideMembers, /// /// No reflection is allowed, nor code generation. This is used as a safeguard when registering types which should not - /// use a standard reflection based descriptor - for example for types implementing + /// use a standard reflection based descriptor - for example for types implementing /// NoReflectionAllowed, /// diff --git a/src/MoonSharp.Interpreter/Interop/InteropRegistrationPolicy.cs b/src/WattleScript.Interpreter/Interop/InteropRegistrationPolicy.cs similarity index 82% rename from src/MoonSharp.Interpreter/Interop/InteropRegistrationPolicy.cs rename to src/WattleScript.Interpreter/Interop/InteropRegistrationPolicy.cs index ac21fcfb..d086d9d8 100644 --- a/src/MoonSharp.Interpreter/Interop/InteropRegistrationPolicy.cs +++ b/src/WattleScript.Interpreter/Interop/InteropRegistrationPolicy.cs @@ -1,7 +1,7 @@ using System; -using MoonSharp.Interpreter.Interop.RegistrationPolicies; +using WattleScript.Interpreter.Interop.RegistrationPolicies; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Collection of the standard policies to handle UserData type registrations. @@ -11,7 +11,7 @@ namespace MoonSharp.Interpreter.Interop public static class InteropRegistrationPolicy { /// - /// The default registration policy used by MoonSharp unless explicitely replaced. + /// The default registration policy used by WattleScript unless explicitely replaced. /// Deregistrations are allowed, but registration of a new descriptor are not allowed /// if a descriptor is already registered for that type. /// @@ -20,7 +20,7 @@ public static class InteropRegistrationPolicy public static IRegistrationPolicy Default { get { return new DefaultRegistrationPolicy(); }} /// - /// The default registration policy used by MoonSharp unless explicitely replaced. + /// The default registration policy used by WattleScript unless explicitely replaced. /// Deregistrations are allowed, but registration of a new descriptor are not allowed /// if a descriptor is already registered for that type. /// diff --git a/src/MoonSharp.Interpreter/Interop/LuaStateInterop/CharPtr.cs b/src/WattleScript.Interpreter/Interop/LuaStateInterop/CharPtr.cs similarity index 99% rename from src/MoonSharp.Interpreter/Interop/LuaStateInterop/CharPtr.cs rename to src/WattleScript.Interpreter/Interop/LuaStateInterop/CharPtr.cs index dc1b2c62..8bf9541a 100644 --- a/src/MoonSharp.Interpreter/Interop/LuaStateInterop/CharPtr.cs +++ b/src/WattleScript.Interpreter/Interop/LuaStateInterop/CharPtr.cs @@ -48,7 +48,7 @@ using System; using System.Diagnostics; -namespace MoonSharp.Interpreter.Interop.LuaStateInterop +namespace WattleScript.Interpreter.Interop.LuaStateInterop { public class CharPtr { diff --git a/src/MoonSharp.Interpreter/Interop/LuaStateInterop/LuaBase.cs b/src/WattleScript.Interpreter/Interop/LuaStateInterop/LuaBase.cs similarity index 99% rename from src/MoonSharp.Interpreter/Interop/LuaStateInterop/LuaBase.cs rename to src/WattleScript.Interpreter/Interop/LuaStateInterop/LuaBase.cs index 1bc2bb2a..8dc88662 100644 --- a/src/MoonSharp.Interpreter/Interop/LuaStateInterop/LuaBase.cs +++ b/src/WattleScript.Interpreter/Interop/LuaStateInterop/LuaBase.cs @@ -4,7 +4,7 @@ using System; using lua_Integer = System.Int32; -namespace MoonSharp.Interpreter.Interop.LuaStateInterop +namespace WattleScript.Interpreter.Interop.LuaStateInterop { /// /// Classes using the classic interface should inherit from this class. diff --git a/src/MoonSharp.Interpreter/Interop/LuaStateInterop/LuaBase_CLib.cs b/src/WattleScript.Interpreter/Interop/LuaStateInterop/LuaBase_CLib.cs similarity index 98% rename from src/MoonSharp.Interpreter/Interop/LuaStateInterop/LuaBase_CLib.cs rename to src/WattleScript.Interpreter/Interop/LuaStateInterop/LuaBase_CLib.cs index b5ebfc2f..a4c25528 100644 --- a/src/MoonSharp.Interpreter/Interop/LuaStateInterop/LuaBase_CLib.cs +++ b/src/WattleScript.Interpreter/Interop/LuaStateInterop/LuaBase_CLib.cs @@ -4,7 +4,7 @@ using System; using lua_Integer = System.Int32; -namespace MoonSharp.Interpreter.Interop.LuaStateInterop +namespace WattleScript.Interpreter.Interop.LuaStateInterop { public partial class LuaBase { diff --git a/src/MoonSharp.Interpreter/Interop/LuaStateInterop/LuaLBuffer.cs b/src/WattleScript.Interpreter/Interop/LuaStateInterop/LuaLBuffer.cs similarity index 85% rename from src/MoonSharp.Interpreter/Interop/LuaStateInterop/LuaLBuffer.cs rename to src/WattleScript.Interpreter/Interop/LuaStateInterop/LuaLBuffer.cs index ed3ba873..5b9d361e 100644 --- a/src/MoonSharp.Interpreter/Interop/LuaStateInterop/LuaLBuffer.cs +++ b/src/WattleScript.Interpreter/Interop/LuaStateInterop/LuaLBuffer.cs @@ -3,7 +3,7 @@ using System.Text; -namespace MoonSharp.Interpreter.Interop.LuaStateInterop +namespace WattleScript.Interpreter.Interop.LuaStateInterop { public class LuaLBuffer { diff --git a/src/MoonSharp.Interpreter/Interop/LuaStateInterop/LuaState.cs b/src/WattleScript.Interpreter/Interop/LuaStateInterop/LuaState.cs similarity index 96% rename from src/MoonSharp.Interpreter/Interop/LuaStateInterop/LuaState.cs rename to src/WattleScript.Interpreter/Interop/LuaStateInterop/LuaState.cs index 94fbbbcb..c5e24a7c 100644 --- a/src/MoonSharp.Interpreter/Interop/LuaStateInterop/LuaState.cs +++ b/src/WattleScript.Interpreter/Interop/LuaStateInterop/LuaState.cs @@ -3,7 +3,7 @@ using System.Collections.Generic; -namespace MoonSharp.Interpreter.Interop.LuaStateInterop +namespace WattleScript.Interpreter.Interop.LuaStateInterop { /// /// diff --git a/src/MoonSharp.Interpreter/Interop/LuaStateInterop/Tools.cs b/src/WattleScript.Interpreter/Interop/LuaStateInterop/Tools.cs similarity index 99% rename from src/MoonSharp.Interpreter/Interop/LuaStateInterop/Tools.cs rename to src/WattleScript.Interpreter/Interop/LuaStateInterop/Tools.cs index 2bef6ad4..c61b3b35 100755 --- a/src/MoonSharp.Interpreter/Interop/LuaStateInterop/Tools.cs +++ b/src/WattleScript.Interpreter/Interop/LuaStateInterop/Tools.cs @@ -55,7 +55,7 @@ #endregion -namespace MoonSharp.Interpreter.Interop.LuaStateInterop +namespace WattleScript.Interpreter.Interop.LuaStateInterop { internal static class Tools { diff --git a/src/MoonSharp.Interpreter/Interop/PredefinedUserData/AnonWrapper.cs b/src/WattleScript.Interpreter/Interop/PredefinedUserData/AnonWrapper.cs similarity index 95% rename from src/MoonSharp.Interpreter/Interop/PredefinedUserData/AnonWrapper.cs rename to src/WattleScript.Interpreter/Interop/PredefinedUserData/AnonWrapper.cs index ddee193b..3e03080c 100644 --- a/src/MoonSharp.Interpreter/Interop/PredefinedUserData/AnonWrapper.cs +++ b/src/WattleScript.Interpreter/Interop/PredefinedUserData/AnonWrapper.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Internal type used by for registration diff --git a/src/MoonSharp.Interpreter/Interop/PredefinedUserData/EnumerableWrapper.cs b/src/WattleScript.Interpreter/Interop/PredefinedUserData/EnumerableWrapper.cs similarity index 96% rename from src/MoonSharp.Interpreter/Interop/PredefinedUserData/EnumerableWrapper.cs rename to src/WattleScript.Interpreter/Interop/PredefinedUserData/EnumerableWrapper.cs index 2d8e18d4..79c5e385 100644 --- a/src/MoonSharp.Interpreter/Interop/PredefinedUserData/EnumerableWrapper.cs +++ b/src/WattleScript.Interpreter/Interop/PredefinedUserData/EnumerableWrapper.cs @@ -1,7 +1,7 @@ using System.Collections; -using MoonSharp.Interpreter.Interop.Converters; +using WattleScript.Interpreter.Interop.Converters; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Wrappers for enumerables as return types diff --git a/src/MoonSharp.Interpreter/Interop/PredefinedUserData/TaskWrapper.cs b/src/WattleScript.Interpreter/Interop/PredefinedUserData/TaskWrapper.cs similarity index 94% rename from src/MoonSharp.Interpreter/Interop/PredefinedUserData/TaskWrapper.cs rename to src/WattleScript.Interpreter/Interop/PredefinedUserData/TaskWrapper.cs index eb8d13f6..c8f4a9a7 100644 --- a/src/MoonSharp.Interpreter/Interop/PredefinedUserData/TaskWrapper.cs +++ b/src/WattleScript.Interpreter/Interop/PredefinedUserData/TaskWrapper.cs @@ -1,9 +1,9 @@ using System; using System.Reflection; using System.Threading.Tasks; -using MoonSharp.Interpreter.Interop.Converters; +using WattleScript.Interpreter.Interop.Converters; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { internal class TaskWrapper { diff --git a/src/MoonSharp.Interpreter/Interop/PropertyTableAssigner.cs b/src/WattleScript.Interpreter/Interop/PropertyTableAssigner.cs similarity index 95% rename from src/MoonSharp.Interpreter/Interop/PropertyTableAssigner.cs rename to src/WattleScript.Interpreter/Interop/PropertyTableAssigner.cs index 05db78ba..aafa3324 100644 --- a/src/MoonSharp.Interpreter/Interop/PropertyTableAssigner.cs +++ b/src/WattleScript.Interpreter/Interop/PropertyTableAssigner.cs @@ -4,11 +4,11 @@ using System.Reflection; using System.Runtime; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Utility class which may be used to set properties on an object of type T, from values contained in a Lua table. - /// Properties must be decorated with the . + /// Properties must be decorated with the . /// This is a generic version of . /// /// The type of the object. @@ -90,7 +90,7 @@ void IPropertyTableAssigner.AssignObjectUnchecked(object o, Table data) /// /// Utility class which may be used to set properties on an object from values contained in a Lua table. - /// Properties must be decorated with the . + /// Properties must be decorated with the . /// See for a generic compile time type-safe version. /// public class PropertyTableAssigner : IPropertyTableAssigner @@ -121,13 +121,13 @@ public PropertyTableAssigner(Type type, params string[] expectedMissingPropertie foreach (PropertyInfo pi in m_Type.GetAllProperties()) { - foreach (MoonSharpPropertyAttribute attr in pi.GetCustomAttributes(true).OfType()) + foreach (WattleScriptPropertyAttribute attr in pi.GetCustomAttributes(true).OfType()) { string name = attr.Name ?? pi.Name; if (m_PropertyMap.ContainsKey(name)) { - throw new ArgumentException(string.Format("Type {0} has two definitions for MoonSharp property {1}", m_Type.FullName, name)); + throw new ArgumentException(string.Format("Type {0} has two definitions for WattleScript property {1}", m_Type.FullName, name)); } else { diff --git a/src/MoonSharp.Interpreter/Interop/ProxyObjects/DelegateProxyFactory.cs b/src/WattleScript.Interpreter/Interop/ProxyObjects/DelegateProxyFactory.cs similarity index 97% rename from src/MoonSharp.Interpreter/Interop/ProxyObjects/DelegateProxyFactory.cs rename to src/WattleScript.Interpreter/Interop/ProxyObjects/DelegateProxyFactory.cs index fb8614b9..a6266ce7 100644 --- a/src/MoonSharp.Interpreter/Interop/ProxyObjects/DelegateProxyFactory.cs +++ b/src/WattleScript.Interpreter/Interop/ProxyObjects/DelegateProxyFactory.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Implementation of IProxyFactory taking two delegates for simple instancing of proxies. diff --git a/src/MoonSharp.Interpreter/Interop/ProxyObjects/IProxyFactory.cs b/src/WattleScript.Interpreter/Interop/ProxyObjects/IProxyFactory.cs similarity index 95% rename from src/MoonSharp.Interpreter/Interop/ProxyObjects/IProxyFactory.cs rename to src/WattleScript.Interpreter/Interop/ProxyObjects/IProxyFactory.cs index 822353a0..7d7a3229 100644 --- a/src/MoonSharp.Interpreter/Interop/ProxyObjects/IProxyFactory.cs +++ b/src/WattleScript.Interpreter/Interop/ProxyObjects/IProxyFactory.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Interface for proxy objects (type unsafe version) diff --git a/src/MoonSharp.Interpreter/Interop/ReflectionExtensions.cs b/src/WattleScript.Interpreter/Interop/ReflectionExtensions.cs similarity index 95% rename from src/MoonSharp.Interpreter/Interop/ReflectionExtensions.cs rename to src/WattleScript.Interpreter/Interop/ReflectionExtensions.cs index daca3d65..add46cb4 100644 --- a/src/MoonSharp.Interpreter/Interop/ReflectionExtensions.cs +++ b/src/WattleScript.Interpreter/Interop/ReflectionExtensions.cs @@ -1,7 +1,7 @@ using System; using System.Reflection; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { static class ReflectionExtensions { diff --git a/src/MoonSharp.Interpreter/Interop/ReflectionSpecialNames.cs b/src/WattleScript.Interpreter/Interop/ReflectionSpecialNames.cs similarity index 99% rename from src/MoonSharp.Interpreter/Interop/ReflectionSpecialNames.cs rename to src/WattleScript.Interpreter/Interop/ReflectionSpecialNames.cs index 0501f2d3..a8ebc98a 100644 --- a/src/MoonSharp.Interpreter/Interop/ReflectionSpecialNames.cs +++ b/src/WattleScript.Interpreter/Interop/ReflectionSpecialNames.cs @@ -1,6 +1,6 @@ using System.Linq; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// diff --git a/src/MoonSharp.Interpreter/Interop/RegistrationPolicies/AutomaticRegistrationPolicy.cs b/src/WattleScript.Interpreter/Interop/RegistrationPolicies/AutomaticRegistrationPolicy.cs similarity index 90% rename from src/MoonSharp.Interpreter/Interop/RegistrationPolicies/AutomaticRegistrationPolicy.cs rename to src/WattleScript.Interpreter/Interop/RegistrationPolicies/AutomaticRegistrationPolicy.cs index f9eb982d..a0d0a0d1 100644 --- a/src/MoonSharp.Interpreter/Interop/RegistrationPolicies/AutomaticRegistrationPolicy.cs +++ b/src/WattleScript.Interpreter/Interop/RegistrationPolicies/AutomaticRegistrationPolicy.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Interop.RegistrationPolicies +namespace WattleScript.Interpreter.Interop.RegistrationPolicies { /// /// Similar to , but with automatic type registration is disabled. diff --git a/src/MoonSharp.Interpreter/Interop/RegistrationPolicies/DefaultRegistrationPolicy.cs b/src/WattleScript.Interpreter/Interop/RegistrationPolicies/DefaultRegistrationPolicy.cs similarity index 85% rename from src/MoonSharp.Interpreter/Interop/RegistrationPolicies/DefaultRegistrationPolicy.cs rename to src/WattleScript.Interpreter/Interop/RegistrationPolicies/DefaultRegistrationPolicy.cs index 4d7328ae..8fca70e7 100644 --- a/src/MoonSharp.Interpreter/Interop/RegistrationPolicies/DefaultRegistrationPolicy.cs +++ b/src/WattleScript.Interpreter/Interop/RegistrationPolicies/DefaultRegistrationPolicy.cs @@ -1,10 +1,10 @@ using System; -using MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; +using WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors; -namespace MoonSharp.Interpreter.Interop.RegistrationPolicies +namespace WattleScript.Interpreter.Interop.RegistrationPolicies { /// - /// The default registration policy used by MoonSharp unless explicitely replaced. + /// The default registration policy used by WattleScript unless explicitely replaced. /// Deregistrations are allowed, but registration of a new descriptor are not allowed /// if a descriptor is already registered for that type. /// diff --git a/src/MoonSharp.Interpreter/Interop/RegistrationPolicies/IRegistrationPolicy.cs b/src/WattleScript.Interpreter/Interop/RegistrationPolicies/IRegistrationPolicy.cs similarity index 94% rename from src/MoonSharp.Interpreter/Interop/RegistrationPolicies/IRegistrationPolicy.cs rename to src/WattleScript.Interpreter/Interop/RegistrationPolicies/IRegistrationPolicy.cs index d4cdf8e5..c304dd8b 100644 --- a/src/MoonSharp.Interpreter/Interop/RegistrationPolicies/IRegistrationPolicy.cs +++ b/src/WattleScript.Interpreter/Interop/RegistrationPolicies/IRegistrationPolicy.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Interop.RegistrationPolicies +namespace WattleScript.Interpreter.Interop.RegistrationPolicies { /// /// Interface for managing how to handle diff --git a/src/MoonSharp.Interpreter/Interop/RegistrationPolicies/PermanentRegistrationPolicy.cs b/src/WattleScript.Interpreter/Interop/RegistrationPolicies/PermanentRegistrationPolicy.cs similarity index 95% rename from src/MoonSharp.Interpreter/Interop/RegistrationPolicies/PermanentRegistrationPolicy.cs rename to src/WattleScript.Interpreter/Interop/RegistrationPolicies/PermanentRegistrationPolicy.cs index 7d984b3d..40c44136 100644 --- a/src/MoonSharp.Interpreter/Interop/RegistrationPolicies/PermanentRegistrationPolicy.cs +++ b/src/WattleScript.Interpreter/Interop/RegistrationPolicies/PermanentRegistrationPolicy.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Interop.RegistrationPolicies +namespace WattleScript.Interpreter.Interop.RegistrationPolicies { /// /// A registration policy which makes registration permanent and not deletable. diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/AutoDescribingUserDataDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/AutoDescribingUserDataDescriptor.cs similarity index 98% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/AutoDescribingUserDataDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/AutoDescribingUserDataDescriptor.cs index 2d282434..d587c664 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/AutoDescribingUserDataDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/AutoDescribingUserDataDescriptor.cs @@ -1,7 +1,7 @@ using System; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.Interop; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Descriptor which acts as a non-containing adapter from IUserDataType to IUserDataDescriptor diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/CompositeUserDataDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/CompositeUserDataDescriptor.cs similarity index 99% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/CompositeUserDataDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/CompositeUserDataDescriptor.cs index 26c9f41b..fa8c24f0 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/CompositeUserDataDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/CompositeUserDataDescriptor.cs @@ -1,7 +1,7 @@ using System; using System.Collections.Generic; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// A user data descriptor which aggregates multiple descriptors and tries dispatching members diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/EventFacade.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/EventFacade.cs similarity index 95% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/EventFacade.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/EventFacade.cs index 6c19c417..ab2d5162 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/EventFacade.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/EventFacade.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Interpreter.Interop.StandardDescriptors +namespace WattleScript.Interpreter.Interop.StandardDescriptors { internal class EventFacade : IUserDataType { diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/DefaultValue.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/DefaultValue.cs similarity index 58% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/DefaultValue.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/DefaultValue.cs index 55fbbac2..8091366f 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/DefaultValue.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/DefaultValue.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors +namespace WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors { public sealed class DefaultValue { diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMemberDescriptor.cs similarity index 87% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMemberDescriptor.cs index 6ebf7363..828f626c 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMemberDescriptor.cs @@ -1,8 +1,8 @@ using System; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.Converters; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.Converters; -namespace MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors +namespace WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors { public abstract class HardwiredMemberDescriptor : IMemberDescriptor { diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMethodMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMethodMemberDescriptor.cs similarity index 86% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMethodMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMethodMemberDescriptor.cs index bcbf0c52..7ac9165e 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMethodMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredMethodMemberDescriptor.cs @@ -1,7 +1,7 @@ using System.Collections.Generic; -using MoonSharp.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.BasicDescriptors; -namespace MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors +namespace WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors { public abstract class HardwiredMethodMemberDescriptor : FunctionMemberDescriptorBase { diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredUserDataDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredUserDataDescriptor.cs similarity index 59% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredUserDataDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredUserDataDescriptor.cs index 3555f9bb..f994b797 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredUserDataDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/HardwiredDescriptors/HardwiredUserDataDescriptor.cs @@ -1,7 +1,7 @@ using System; -using MoonSharp.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.BasicDescriptors; -namespace MoonSharp.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors +namespace WattleScript.Interpreter.Interop.StandardDescriptors.HardwiredDescriptors { public abstract class HardwiredUserDataDescriptor : DispatchingUserDataDescriptor { diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/MemberDescriptors/ArrayMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/MemberDescriptors/ArrayMemberDescriptor.cs similarity index 95% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/MemberDescriptors/ArrayMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/MemberDescriptors/ArrayMemberDescriptor.cs index 0e9f4c09..196fbd63 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/MemberDescriptors/ArrayMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/MemberDescriptors/ArrayMemberDescriptor.cs @@ -1,8 +1,8 @@ using System; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.Converters; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.Converters; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Member descriptor for indexer of array types diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/MemberDescriptors/DynValueMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/MemberDescriptors/DynValueMemberDescriptor.cs similarity index 97% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/MemberDescriptors/DynValueMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/MemberDescriptors/DynValueMemberDescriptor.cs index eede96e8..de739407 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/MemberDescriptors/DynValueMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/MemberDescriptors/DynValueMemberDescriptor.cs @@ -1,6 +1,6 @@ -using MoonSharp.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.BasicDescriptors; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Class providing a simple descriptor for constant DynValues in userdata diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/MemberDescriptors/FunctionMemberDescriptorBase.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/MemberDescriptors/FunctionMemberDescriptorBase.cs similarity index 98% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/MemberDescriptors/FunctionMemberDescriptorBase.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/MemberDescriptors/FunctionMemberDescriptorBase.cs index 6c1b5753..cb0d520e 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/MemberDescriptors/FunctionMemberDescriptorBase.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/MemberDescriptors/FunctionMemberDescriptorBase.cs @@ -2,10 +2,10 @@ using System.Collections.Generic; using System.Linq; using System.Reflection; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.Converters; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.Converters; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Class providing easier marshalling of CLR functions diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/MemberDescriptors/ObjectCallbackMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/MemberDescriptors/ObjectCallbackMemberDescriptor.cs similarity index 94% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/MemberDescriptors/ObjectCallbackMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/MemberDescriptors/ObjectCallbackMemberDescriptor.cs index 0fa3f834..c0ad4b6e 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/MemberDescriptors/ObjectCallbackMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/MemberDescriptors/ObjectCallbackMemberDescriptor.cs @@ -1,8 +1,8 @@ using System; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.Converters; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.Converters; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Member descriptor which allows to define new members which behave similarly to class instance members diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ProxyUserDataDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ProxyUserDataDescriptor.cs similarity index 98% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/ProxyUserDataDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/ProxyUserDataDescriptor.cs index 649a8f91..01fef094 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ProxyUserDataDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ProxyUserDataDescriptor.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Data descriptor used for proxy objects diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/EventMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/EventMemberDescriptor.cs similarity index 98% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/EventMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/EventMemberDescriptor.cs index 6343d188..d1402177 100755 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/EventMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/EventMemberDescriptor.cs @@ -2,11 +2,11 @@ using System.Collections.Generic; using System.Linq; using System.Reflection; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.StandardDescriptors; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.StandardDescriptors; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Class providing easier marshalling of CLR events. Handling is limited to a narrow range of handler signatures, which, diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/FieldMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/FieldMemberDescriptor.cs similarity index 97% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/FieldMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/FieldMemberDescriptor.cs index cec0f656..9f13ac12 100755 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/FieldMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/FieldMemberDescriptor.cs @@ -2,11 +2,11 @@ using System.Linq.Expressions; using System.Reflection; using System.Threading; -using MoonSharp.Interpreter.Diagnostics; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.Converters; +using WattleScript.Interpreter.Diagnostics; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.Converters; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Class providing easier marshalling of CLR fields diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/MethodMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/MethodMemberDescriptor.cs similarity index 98% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/MethodMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/MethodMemberDescriptor.cs index 9901da74..7219817e 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/MethodMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/MethodMemberDescriptor.cs @@ -5,10 +5,10 @@ using System.Reflection; using System.Runtime.CompilerServices; using System.Threading; -using MoonSharp.Interpreter.Diagnostics; -using MoonSharp.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Diagnostics; +using WattleScript.Interpreter.Interop.BasicDescriptors; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Class providing easier marshalling of CLR functions diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/OverloadedMethodMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/OverloadedMethodMemberDescriptor.cs similarity index 99% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/OverloadedMethodMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/OverloadedMethodMemberDescriptor.cs index 2a4f7eb7..b02a059d 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/OverloadedMethodMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/OverloadedMethodMemberDescriptor.cs @@ -3,10 +3,10 @@ using System; using System.Collections.Generic; using System.Linq; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.Converters; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.Converters; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Class providing easier marshalling of overloaded CLR functions diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/PropertyMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/PropertyMemberDescriptor.cs similarity index 98% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/PropertyMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/PropertyMemberDescriptor.cs index 3477cdb4..a81a0bc7 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/PropertyMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/PropertyMemberDescriptor.cs @@ -2,11 +2,11 @@ using System.Linq.Expressions; using System.Reflection; using System.Threading; -using MoonSharp.Interpreter.Diagnostics; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.Converters; +using WattleScript.Interpreter.Diagnostics; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.Converters; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Class providing easier marshalling of CLR properties diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/ValueTypeDefaultCtorMemberDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/ValueTypeDefaultCtorMemberDescriptor.cs similarity index 97% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/ValueTypeDefaultCtorMemberDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/ValueTypeDefaultCtorMemberDescriptor.cs index 4bcf2017..48b38184 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/ValueTypeDefaultCtorMemberDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/ValueTypeDefaultCtorMemberDescriptor.cs @@ -1,8 +1,8 @@ using System; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.Converters; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.Converters; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Member descriptor for the default constructor of value types. diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/StandardEnumUserDataDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/StandardEnumUserDataDescriptor.cs similarity index 99% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/StandardEnumUserDataDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/StandardEnumUserDataDescriptor.cs index c7b4c2f9..6b29b32d 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/StandardEnumUserDataDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/StandardEnumUserDataDescriptor.cs @@ -1,8 +1,8 @@ using System; using System.Linq; -using MoonSharp.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.BasicDescriptors; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Standard descriptor for Enum values diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/StandardGenericsUserDataDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/StandardGenericsUserDataDescriptor.cs similarity index 97% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/StandardGenericsUserDataDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/StandardGenericsUserDataDescriptor.cs index fd5983a2..b3dcf6d4 100644 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/StandardGenericsUserDataDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/StandardGenericsUserDataDescriptor.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Standard user data descriptor used to instantiate generics. diff --git a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/StandardUserDataDescriptor.cs b/src/WattleScript.Interpreter/Interop/StandardDescriptors/StandardUserDataDescriptor.cs similarity index 95% rename from src/MoonSharp.Interpreter/Interop/StandardDescriptors/StandardUserDataDescriptor.cs rename to src/WattleScript.Interpreter/Interop/StandardDescriptors/StandardUserDataDescriptor.cs index 9ede8fbe..94ad5fb2 100755 --- a/src/MoonSharp.Interpreter/Interop/StandardDescriptors/StandardUserDataDescriptor.cs +++ b/src/WattleScript.Interpreter/Interop/StandardDescriptors/StandardUserDataDescriptor.cs @@ -2,9 +2,9 @@ using System.Collections.Generic; using System.Linq; using System.Reflection; -using MoonSharp.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.BasicDescriptors; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Standard descriptor for userdata types. @@ -45,8 +45,8 @@ public StandardUserDataDescriptor(Type type, InteropAccessMode accessMode, strin private void FillMemberList() { HashSet membersToIgnore = new HashSet( - this.Type.GetCustomAttributes( typeof(MoonSharpHideMemberAttribute), true) - .OfType() + this.Type.GetCustomAttributes( typeof(WattleScriptHideMemberAttribute), true) + .OfType() .Select(a => a.MemberName) ); @@ -135,7 +135,7 @@ private void FillMemberList() if (!nestedType.IsGenericTypeDefinition) { - if (nestedType.IsNestedPublic || nestedType.GetCustomAttributes(typeof(MoonSharpUserDataAttribute), true).Length > 0) + if (nestedType.IsNestedPublic || nestedType.GetCustomAttributes(typeof(WattleScriptUserDataAttribute), true).Length > 0) { var descr = UserData.RegisterType(nestedType, this.AccessMode); diff --git a/src/MoonSharp.Interpreter/Interop/UserDataMemberType.cs b/src/WattleScript.Interpreter/Interop/UserDataMemberType.cs similarity index 81% rename from src/MoonSharp.Interpreter/Interop/UserDataMemberType.cs rename to src/WattleScript.Interpreter/Interop/UserDataMemberType.cs index 35d33681..51f614d2 100644 --- a/src/MoonSharp.Interpreter/Interop/UserDataMemberType.cs +++ b/src/WattleScript.Interpreter/Interop/UserDataMemberType.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { public enum UserDataMemberType { diff --git a/src/MoonSharp.Interpreter/Interop/UserDataRegistries/ExtensionMethodsRegistry.cs b/src/WattleScript.Interpreter/Interop/UserDataRegistries/ExtensionMethodsRegistry.cs similarity index 96% rename from src/MoonSharp.Interpreter/Interop/UserDataRegistries/ExtensionMethodsRegistry.cs rename to src/WattleScript.Interpreter/Interop/UserDataRegistries/ExtensionMethodsRegistry.cs index 03c43825..f1fd9a15 100755 --- a/src/MoonSharp.Interpreter/Interop/UserDataRegistries/ExtensionMethodsRegistry.cs +++ b/src/WattleScript.Interpreter/Interop/UserDataRegistries/ExtensionMethodsRegistry.cs @@ -3,10 +3,10 @@ using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Interop.BasicDescriptors; -namespace MoonSharp.Interpreter.Interop.UserDataRegistries +namespace WattleScript.Interpreter.Interop.UserDataRegistries { /// /// Registry of all extension methods. Use UserData statics to access these. diff --git a/src/MoonSharp.Interpreter/Interop/UserDataRegistries/TypeDescriptorRegistry.cs b/src/WattleScript.Interpreter/Interop/UserDataRegistries/TypeDescriptorRegistry.cs similarity index 95% rename from src/MoonSharp.Interpreter/Interop/UserDataRegistries/TypeDescriptorRegistry.cs rename to src/WattleScript.Interpreter/Interop/UserDataRegistries/TypeDescriptorRegistry.cs index 9ec93738..28171ff5 100755 --- a/src/MoonSharp.Interpreter/Interop/UserDataRegistries/TypeDescriptorRegistry.cs +++ b/src/WattleScript.Interpreter/Interop/UserDataRegistries/TypeDescriptorRegistry.cs @@ -4,10 +4,10 @@ using System.Reflection; using System.Runtime.CompilerServices; using System.Threading; -using MoonSharp.Interpreter.Interop.BasicDescriptors; -using MoonSharp.Interpreter.Interop.RegistrationPolicies; +using WattleScript.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.RegistrationPolicies; -namespace MoonSharp.Interpreter.Interop.UserDataRegistries +namespace WattleScript.Interpreter.Interop.UserDataRegistries { /// /// Registry of all type descriptors. Use UserData statics to access these. @@ -20,7 +20,7 @@ internal static class TypeDescriptorRegistry private static InteropAccessMode s_DefaultAccessMode; /// - /// Registers all types marked with a MoonSharpUserDataAttribute that ar contained in an assembly. + /// Registers all types marked with a WattleScriptUserDataAttribute that ar contained in an assembly. /// /// The assembly. /// if set to true extension types are registered to the appropriate registry. @@ -46,14 +46,14 @@ internal static void RegisterAssembly(Assembly asm = null, bool includeExtension var userDataTypes = from t in asm.SafeGetTypes() - let attributes = t.GetCustomAttributes(typeof(MoonSharpUserDataAttribute), true) + let attributes = t.GetCustomAttributes(typeof(WattleScriptUserDataAttribute), true) where attributes != null && attributes.Length > 0 select new { Attributes = attributes, DataType = t }; foreach (var userDataType in userDataTypes) { UserData.RegisterType(userDataType.DataType, userDataType.Attributes - .OfType() + .OfType() .First() .AccessMode); } @@ -212,7 +212,7 @@ internal static InteropAccessMode ResolveDefaultAccessModeForType(InteropAccessM { if (accessMode == InteropAccessMode.Default) { - MoonSharpUserDataAttribute attr = type.GetCustomAttributes(true).OfType() + WattleScriptUserDataAttribute attr = type.GetCustomAttributes(true).OfType() .SingleOrDefault(); if (attr != null) diff --git a/src/MoonSharp.Interpreter/LinqHelpers.cs b/src/WattleScript.Interpreter/LinqHelpers.cs similarity index 97% rename from src/MoonSharp.Interpreter/LinqHelpers.cs rename to src/WattleScript.Interpreter/LinqHelpers.cs index 1b92920e..5cf54f07 100644 --- a/src/MoonSharp.Interpreter/LinqHelpers.cs +++ b/src/WattleScript.Interpreter/LinqHelpers.cs @@ -1,7 +1,7 @@ using System.Collections.Generic; using System.Linq; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// LINQ helper methods diff --git a/src/MoonSharp.Interpreter/Loaders/EmbeddedResourcesScriptLoader.cs b/src/WattleScript.Interpreter/Loaders/EmbeddedResourcesScriptLoader.cs similarity index 98% rename from src/MoonSharp.Interpreter/Loaders/EmbeddedResourcesScriptLoader.cs rename to src/WattleScript.Interpreter/Loaders/EmbeddedResourcesScriptLoader.cs index 1327e499..10796562 100644 --- a/src/MoonSharp.Interpreter/Loaders/EmbeddedResourcesScriptLoader.cs +++ b/src/WattleScript.Interpreter/Loaders/EmbeddedResourcesScriptLoader.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Reflection; -namespace MoonSharp.Interpreter.Loaders +namespace WattleScript.Interpreter.Loaders { /// /// A script loader loading scripts from an assembly resources diff --git a/src/MoonSharp.Interpreter/Loaders/FileSystemScriptLoader.cs b/src/WattleScript.Interpreter/Loaders/FileSystemScriptLoader.cs similarity index 96% rename from src/MoonSharp.Interpreter/Loaders/FileSystemScriptLoader.cs rename to src/WattleScript.Interpreter/Loaders/FileSystemScriptLoader.cs index ea0bfde0..722a1d52 100755 --- a/src/MoonSharp.Interpreter/Loaders/FileSystemScriptLoader.cs +++ b/src/WattleScript.Interpreter/Loaders/FileSystemScriptLoader.cs @@ -1,6 +1,6 @@ using System.IO; -namespace MoonSharp.Interpreter.Loaders +namespace WattleScript.Interpreter.Loaders { /// /// A script loader loading scripts directly from the file system (does not go through platform object) diff --git a/src/MoonSharp.Interpreter/Loaders/IScriptLoader.cs b/src/WattleScript.Interpreter/Loaders/IScriptLoader.cs similarity index 97% rename from src/MoonSharp.Interpreter/Loaders/IScriptLoader.cs rename to src/WattleScript.Interpreter/Loaders/IScriptLoader.cs index f160abe6..7df1e932 100644 --- a/src/MoonSharp.Interpreter/Loaders/IScriptLoader.cs +++ b/src/WattleScript.Interpreter/Loaders/IScriptLoader.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Loaders +namespace WattleScript.Interpreter.Loaders { /// /// Class dictating how requests to read scripts from files are handled. diff --git a/src/MoonSharp.Interpreter/Loaders/InvalidScriptLoader.cs b/src/WattleScript.Interpreter/Loaders/InvalidScriptLoader.cs similarity index 95% rename from src/MoonSharp.Interpreter/Loaders/InvalidScriptLoader.cs rename to src/WattleScript.Interpreter/Loaders/InvalidScriptLoader.cs index 583382e4..a1ac4d76 100644 --- a/src/MoonSharp.Interpreter/Loaders/InvalidScriptLoader.cs +++ b/src/WattleScript.Interpreter/Loaders/InvalidScriptLoader.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Loaders +namespace WattleScript.Interpreter.Loaders { /// /// A script loader used for platforms we cannot initialize in any better way.. diff --git a/src/MoonSharp.Interpreter/Loaders/ScriptLoaderBase.cs b/src/WattleScript.Interpreter/Loaders/ScriptLoaderBase.cs similarity index 99% rename from src/MoonSharp.Interpreter/Loaders/ScriptLoaderBase.cs rename to src/WattleScript.Interpreter/Loaders/ScriptLoaderBase.cs index 0b189b4b..15c51dee 100644 --- a/src/MoonSharp.Interpreter/Loaders/ScriptLoaderBase.cs +++ b/src/WattleScript.Interpreter/Loaders/ScriptLoaderBase.cs @@ -1,7 +1,7 @@ using System; using System.Linq; -namespace MoonSharp.Interpreter.Loaders +namespace WattleScript.Interpreter.Loaders { /// /// A base implementation of IScriptLoader, offering resolution of module names. diff --git a/src/MoonSharp.Interpreter/Loaders/UnityAssetsScriptLoader.cs b/src/WattleScript.Interpreter/Loaders/UnityAssetsScriptLoader.cs similarity index 93% rename from src/MoonSharp.Interpreter/Loaders/UnityAssetsScriptLoader.cs rename to src/WattleScript.Interpreter/Loaders/UnityAssetsScriptLoader.cs index 620ad7ae..0054feb3 100755 --- a/src/MoonSharp.Interpreter/Loaders/UnityAssetsScriptLoader.cs +++ b/src/WattleScript.Interpreter/Loaders/UnityAssetsScriptLoader.cs @@ -3,14 +3,14 @@ using System.Linq; using System.Reflection; -namespace MoonSharp.Interpreter.Loaders +namespace WattleScript.Interpreter.Loaders { /// /// A script loader which can load scripts from assets in Unity3D. /// Scripts should be saved as .txt files in a subdirectory of Assets/Resources. /// - /// When MoonSharp is activated on Unity3D and the default script loader is used, - /// scripts should be saved as .txt files in Assets/Resources/MoonSharp/Scripts. + /// When WattleScript is activated on Unity3D and the default script loader is used, + /// scripts should be saved as .txt files in Assets/Resources/WattleScript/Scripts. /// public class UnityAssetsScriptLoader : ScriptLoaderBase { @@ -19,14 +19,14 @@ public class UnityAssetsScriptLoader : ScriptLoaderBase /// /// The default path where scripts are meant to be stored (if not changed) /// - public const string DEFAULT_PATH = "MoonSharp/Scripts"; + public const string DEFAULT_PATH = "WattleScript/Scripts"; /// /// Initializes a new instance of the class. /// /// The path, relative to Assets/Resources. For example /// if your scripts are stored under Assets/Resources/Scripts, you should - /// pass the value "Scripts". If null, "MoonSharp/Scripts" is used. + /// pass the value "Scripts". If null, "WattleScript/Scripts" is used. public UnityAssetsScriptLoader(string assetsPath = null) { assetsPath = assetsPath ?? DEFAULT_PATH; diff --git a/src/MoonSharp.Interpreter/Modules/CoreModules.cs b/src/WattleScript.Interpreter/Modules/CoreModules.cs similarity index 95% rename from src/MoonSharp.Interpreter/Modules/CoreModules.cs rename to src/WattleScript.Interpreter/Modules/CoreModules.cs index 3f95615c..f97ef3ee 100755 --- a/src/MoonSharp.Interpreter/Modules/CoreModules.cs +++ b/src/WattleScript.Interpreter/Modules/CoreModules.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Enumeration (combinable as flags) of all the standard library modules @@ -74,11 +74,11 @@ public enum CoreModules /// Debug = 0x4000, /// - /// The "dynamic" package (introduced by MoonSharp). + /// The "dynamic" package (introduced by WattleScript). /// Dynamic = 0x8000, /// - /// The "json" package (introduced by MoonSharp). + /// The "json" package (introduced by WattleScript). /// Json = 0x10000, diff --git a/src/MoonSharp.Interpreter/Modules/ModuleRegister.cs b/src/WattleScript.Interpreter/Modules/ModuleRegister.cs similarity index 85% rename from src/MoonSharp.Interpreter/Modules/ModuleRegister.cs rename to src/WattleScript.Interpreter/Modules/ModuleRegister.cs index 8d82d0c0..b97e7a3b 100755 --- a/src/MoonSharp.Interpreter/Modules/ModuleRegister.cs +++ b/src/WattleScript.Interpreter/Modules/ModuleRegister.cs @@ -1,11 +1,11 @@ using System; using System.Linq; using System.Reflection; -using MoonSharp.Interpreter.CoreLib; -using MoonSharp.Interpreter.Platforms; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.CoreLib; +using WattleScript.Interpreter.Platforms; +using WattleScript.Interpreter.Interop; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Class managing modules (mostly as extension methods) @@ -57,7 +57,7 @@ public static Table RegisterConstants(this Table table) Table m = moonsharp_table.Table; table.Set("_G", DynValue.NewTable(table)); - table.Set("_VERSION", DynValue.NewString(string.Format("MoonSharp {0}", Script.VERSION))); + table.Set("_VERSION", DynValue.NewString(string.Format("WattleScript {0}", Script.VERSION))); table.Set("_MOONSHARP", moonsharp_table); m.Set("version", DynValue.NewString(Script.VERSION)); @@ -88,9 +88,9 @@ public static Table RegisterModuleType(this Table gtable, Type t) foreach (MethodInfo mi in t.GetAllMethods().Where(__mi => __mi.IsStatic)) { - if (mi.GetCustomAttributes(typeof(MoonSharpModuleMethodAttribute), false).ToArray().Length > 0) + if (mi.GetCustomAttributes(typeof(WattleScriptModuleMethodAttribute), false).ToArray().Length > 0) { - MoonSharpModuleMethodAttribute attr = (MoonSharpModuleMethodAttribute)mi.GetCustomAttributes(typeof(MoonSharpModuleMethodAttribute), false).First(); + WattleScriptModuleMethodAttribute attr = (WattleScriptModuleMethodAttribute)mi.GetCustomAttributes(typeof(WattleScriptModuleMethodAttribute), false).First(); if (!CallbackFunction.CheckCallbackSignature(mi, true)) throw new ArgumentException(string.Format("Method {0} does not have the right signature.", mi.Name)); @@ -106,24 +106,24 @@ public static Table RegisterModuleType(this Table gtable, Type t) table.Set(name, DynValue.NewCallback(func, name)); } - else if (mi.Name == "MoonSharpInit") + else if (mi.Name == "WattleScriptInit") { object[] args = new object[2] { gtable, table }; mi.Invoke(null, args); } } - foreach (FieldInfo fi in t.GetAllFields().Where(_mi => _mi.IsStatic && _mi.GetCustomAttributes(typeof(MoonSharpModuleMethodAttribute), false).ToArray().Length > 0)) + foreach (FieldInfo fi in t.GetAllFields().Where(_mi => _mi.IsStatic && _mi.GetCustomAttributes(typeof(WattleScriptModuleMethodAttribute), false).ToArray().Length > 0)) { - MoonSharpModuleMethodAttribute attr = (MoonSharpModuleMethodAttribute)fi.GetCustomAttributes(typeof(MoonSharpModuleMethodAttribute), false).First(); + WattleScriptModuleMethodAttribute attr = (WattleScriptModuleMethodAttribute)fi.GetCustomAttributes(typeof(WattleScriptModuleMethodAttribute), false).First(); string name = (!string.IsNullOrEmpty(attr.Name)) ? attr.Name : fi.Name; RegisterScriptField(fi, null, table, t, name); } - foreach (FieldInfo fi in t.GetAllFields().Where(_mi => _mi.IsStatic && _mi.GetCustomAttributes(typeof(MoonSharpModuleConstantAttribute), false).ToArray().Length > 0)) + foreach (FieldInfo fi in t.GetAllFields().Where(_mi => _mi.IsStatic && _mi.GetCustomAttributes(typeof(WattleScriptModuleConstantAttribute), false).ToArray().Length > 0)) { - MoonSharpModuleConstantAttribute attr = (MoonSharpModuleConstantAttribute)fi.GetCustomAttributes(typeof(MoonSharpModuleConstantAttribute), false).First(); + WattleScriptModuleConstantAttribute attr = (WattleScriptModuleConstantAttribute)fi.GetCustomAttributes(typeof(WattleScriptModuleConstantAttribute), false).First(); string name = (!string.IsNullOrEmpty(attr.Name)) ? attr.Name : fi.Name; RegisterScriptFieldAsConst(fi, null, table, t, name); @@ -167,7 +167,7 @@ private static void RegisterScriptField(FieldInfo fi, object o, Table table, Typ private static Table CreateModuleNamespace(Table gtable, Type t) { - MoonSharpModuleAttribute attr = (MoonSharpModuleAttribute)(t.GetCustomAttributes(typeof(MoonSharpModuleAttribute), false).First()); + WattleScriptModuleAttribute attr = (WattleScriptModuleAttribute)(t.GetCustomAttributes(typeof(WattleScriptModuleAttribute), false).First()); if (string.IsNullOrEmpty(attr.Namespace)) { diff --git a/src/MoonSharp.Interpreter/Modules/MoonSharpModuleAttribute.cs b/src/WattleScript.Interpreter/Modules/MoonSharpModuleAttribute.cs similarity index 87% rename from src/MoonSharp.Interpreter/Modules/MoonSharpModuleAttribute.cs rename to src/WattleScript.Interpreter/Modules/MoonSharpModuleAttribute.cs index 64b5deb1..dd1f3149 100644 --- a/src/MoonSharp.Interpreter/Modules/MoonSharpModuleAttribute.cs +++ b/src/WattleScript.Interpreter/Modules/MoonSharpModuleAttribute.cs @@ -1,9 +1,9 @@ using System; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// - /// Marks a CLR type to be a MoonSharp module. + /// Marks a CLR type to be a WattleScript module. /// Modules are the fastest way to bring interop between scripts and CLR code, albeit at the cost of a very increased /// complexity in writing them. Modules is what's used for the standard library, for maximum efficiency. /// @@ -18,7 +18,7 @@ namespace MoonSharp.Interpreter /// See for easier object marshalling. /// [AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)] - public sealed class MoonSharpModuleAttribute : Attribute + public sealed class WattleScriptModuleAttribute : Attribute { /// /// Gets or sets the namespace, that is the name of the table which will contain the defined functions. diff --git a/src/MoonSharp.Interpreter/Modules/MoonSharpModuleConstantAttribute.cs b/src/WattleScript.Interpreter/Modules/MoonSharpModuleConstantAttribute.cs similarity index 68% rename from src/MoonSharp.Interpreter/Modules/MoonSharpModuleConstantAttribute.cs rename to src/WattleScript.Interpreter/Modules/MoonSharpModuleConstantAttribute.cs index b633bed2..44f82428 100644 --- a/src/MoonSharp.Interpreter/Modules/MoonSharpModuleConstantAttribute.cs +++ b/src/WattleScript.Interpreter/Modules/MoonSharpModuleConstantAttribute.cs @@ -1,14 +1,14 @@ using System; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// In a module type, mark fields with this attribute to have them exposed as a module constant. /// - /// See for more information about modules. + /// See for more information about modules. /// [AttributeUsage(AttributeTargets.Field, Inherited = false, AllowMultiple = false)] - public sealed class MoonSharpModuleConstantAttribute : Attribute + public sealed class WattleScriptModuleConstantAttribute : Attribute { /// /// Gets or sets the name of the constant - if different from the name of the field itself diff --git a/src/MoonSharp.Interpreter/Modules/MoonSharpModuleMethodAttribute.cs b/src/WattleScript.Interpreter/Modules/MoonSharpModuleMethodAttribute.cs similarity index 76% rename from src/MoonSharp.Interpreter/Modules/MoonSharpModuleMethodAttribute.cs rename to src/WattleScript.Interpreter/Modules/MoonSharpModuleMethodAttribute.cs index 50b58f51..838f1ab0 100644 --- a/src/MoonSharp.Interpreter/Modules/MoonSharpModuleMethodAttribute.cs +++ b/src/WattleScript.Interpreter/Modules/MoonSharpModuleMethodAttribute.cs @@ -1,16 +1,16 @@ using System; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// In a module type, mark methods or fields with this attribute to have them exposed as module functions. /// Methods must have the signature "public static DynValue ...(ScriptExecutionContextCallbackArguments)". /// Fields must be static or const strings, with an anonymous Lua function inside. /// - /// See for more information about modules. + /// See for more information about modules. /// [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field, Inherited = false, AllowMultiple = false)] - public sealed class MoonSharpModuleMethodAttribute : Attribute + public sealed class WattleScriptModuleMethodAttribute : Attribute { /// /// Gets or sets the name of the function in the module (defaults to member name) diff --git a/src/MoonSharp.Interpreter/NameSpace_XmlHelp.cs b/src/WattleScript.Interpreter/NameSpace_XmlHelp.cs similarity index 80% rename from src/MoonSharp.Interpreter/NameSpace_XmlHelp.cs rename to src/WattleScript.Interpreter/NameSpace_XmlHelp.cs index 8f2615bb..d32b39aa 100644 --- a/src/MoonSharp.Interpreter/NameSpace_XmlHelp.cs +++ b/src/WattleScript.Interpreter/NameSpace_XmlHelp.cs @@ -1,23 +1,23 @@  -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// - /// Namespace containing all the most commonly used classes for MoonSharp operation. + /// Namespace containing all the most commonly used classes for WattleScript operation. /// When in doubt, refer to and classes as starting points. /// internal static class NamespaceDoc { } } -namespace MoonSharp.Interpreter.CoreLib +namespace WattleScript.Interpreter.CoreLib { /// - /// Namespace containing the implementation of the Lua standard library, as MoonSharp modules. + /// Namespace containing the implementation of the Lua standard library, as WattleScript modules. /// There's seldom the need to access these classes directly. /// internal static class NamespaceDoc { } } -namespace MoonSharp.Interpreter.CoreLib.IO +namespace WattleScript.Interpreter.CoreLib.IO { /// /// Namespace containing userdata classes for the 'io' module @@ -25,7 +25,7 @@ namespace MoonSharp.Interpreter.CoreLib.IO internal static class NamespaceDoc { } } -namespace MoonSharp.Interpreter.Debugging +namespace WattleScript.Interpreter.Debugging { /// /// Namespace containing classes used to support debuggers @@ -33,7 +33,7 @@ namespace MoonSharp.Interpreter.Debugging internal static class NamespaceDoc { } } -namespace MoonSharp.Interpreter.Diagnostics +namespace WattleScript.Interpreter.Diagnostics { /// /// Namespace containing classes used to support self diagnostics (e.g. performance counters) @@ -41,7 +41,7 @@ namespace MoonSharp.Interpreter.Diagnostics internal static class NamespaceDoc { } } -namespace MoonSharp.Interpreter.Interop +namespace WattleScript.Interpreter.Interop { /// /// Namespace containing classes used to customize and support advanced interoperations between @@ -50,7 +50,7 @@ namespace MoonSharp.Interpreter.Interop internal static class NamespaceDoc { } } -namespace MoonSharp.Interpreter.Interop.LuaStateInterop +namespace WattleScript.Interpreter.Interop.LuaStateInterop { /// /// Namespace containing classes used to provide a minimal support for porting code based on the classic @@ -60,7 +60,7 @@ internal static class NamespaceDoc { } } -namespace MoonSharp.Interpreter.Loaders +namespace WattleScript.Interpreter.Loaders { /// /// Namespace containing classes used to customized how scripts are loaded from external files. @@ -69,7 +69,7 @@ internal static class NamespaceDoc { } } -namespace MoonSharp.Interpreter.Platforms +namespace WattleScript.Interpreter.Platforms { /// /// Namespace containing classes used to customize how the interfacing with the operative system happens @@ -79,7 +79,7 @@ namespace MoonSharp.Interpreter.Platforms internal static class NamespaceDoc { } } -namespace MoonSharp.Interpreter.REPL +namespace WattleScript.Interpreter.REPL { /// /// Contains classes useful to implement REPL interpreters. diff --git a/src/MoonSharp.Interpreter/Options/ColonOperatorBehaviour.cs b/src/WattleScript.Interpreter/Options/ColonOperatorBehaviour.cs similarity index 95% rename from src/MoonSharp.Interpreter/Options/ColonOperatorBehaviour.cs rename to src/WattleScript.Interpreter/Options/ColonOperatorBehaviour.cs index c8b9a04e..7d573507 100644 --- a/src/MoonSharp.Interpreter/Options/ColonOperatorBehaviour.cs +++ b/src/WattleScript.Interpreter/Options/ColonOperatorBehaviour.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Defines behaviour of the colon ':' operator in CLR callbacks. diff --git a/src/MoonSharp.Interpreter/Options/FuzzySymbolMatchingBehavior.cs b/src/WattleScript.Interpreter/Options/FuzzySymbolMatchingBehavior.cs similarity index 95% rename from src/MoonSharp.Interpreter/Options/FuzzySymbolMatchingBehavior.cs rename to src/WattleScript.Interpreter/Options/FuzzySymbolMatchingBehavior.cs index dcb0a006..607947db 100644 --- a/src/MoonSharp.Interpreter/Options/FuzzySymbolMatchingBehavior.cs +++ b/src/WattleScript.Interpreter/Options/FuzzySymbolMatchingBehavior.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter { +namespace WattleScript.Interpreter { /// /// A flag that controls if/how symbols (method, property, userdata) are fuzzily matched when they do not exist. Flags can be combined for multiple checks. diff --git a/src/MoonSharp.Interpreter/Options/ScriptSyntax.cs b/src/WattleScript.Interpreter/Options/ScriptSyntax.cs similarity index 93% rename from src/MoonSharp.Interpreter/Options/ScriptSyntax.cs rename to src/WattleScript.Interpreter/Options/ScriptSyntax.cs index 2f4890e0..a5f19148 100644 --- a/src/MoonSharp.Interpreter/Options/ScriptSyntax.cs +++ b/src/WattleScript.Interpreter/Options/ScriptSyntax.cs @@ -1,4 +1,4 @@ -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Defines the syntax used by the compiler diff --git a/src/MoonSharp.Interpreter/Platforms/IPlatformAccessor.cs b/src/WattleScript.Interpreter/Platforms/IPlatformAccessor.cs similarity index 99% rename from src/MoonSharp.Interpreter/Platforms/IPlatformAccessor.cs rename to src/WattleScript.Interpreter/Platforms/IPlatformAccessor.cs index 0fe38d6c..59283178 100644 --- a/src/MoonSharp.Interpreter/Platforms/IPlatformAccessor.cs +++ b/src/WattleScript.Interpreter/Platforms/IPlatformAccessor.cs @@ -1,7 +1,7 @@ using System.IO; using System.Text; -namespace MoonSharp.Interpreter.Platforms +namespace WattleScript.Interpreter.Platforms { /// /// Interface to abstract all accesses made to the underlying platform (OS, framework) by the scripting engine. diff --git a/src/MoonSharp.Interpreter/Platforms/LimitedPlatformAccessor.cs b/src/WattleScript.Interpreter/Platforms/LimitedPlatformAccessor.cs similarity index 99% rename from src/MoonSharp.Interpreter/Platforms/LimitedPlatformAccessor.cs rename to src/WattleScript.Interpreter/Platforms/LimitedPlatformAccessor.cs index 18bd1765..839b5b9d 100644 --- a/src/MoonSharp.Interpreter/Platforms/LimitedPlatformAccessor.cs +++ b/src/WattleScript.Interpreter/Platforms/LimitedPlatformAccessor.cs @@ -1,7 +1,7 @@ using System; using System.Text; -namespace MoonSharp.Interpreter.Platforms +namespace WattleScript.Interpreter.Platforms { /// /// A class implementing all the bits needed to have a minimal support of a platform. diff --git a/src/MoonSharp.Interpreter/Platforms/PlatformAccessorBase.cs b/src/WattleScript.Interpreter/Platforms/PlatformAccessorBase.cs similarity index 99% rename from src/MoonSharp.Interpreter/Platforms/PlatformAccessorBase.cs rename to src/WattleScript.Interpreter/Platforms/PlatformAccessorBase.cs index ea44da1e..110d06ca 100755 --- a/src/MoonSharp.Interpreter/Platforms/PlatformAccessorBase.cs +++ b/src/WattleScript.Interpreter/Platforms/PlatformAccessorBase.cs @@ -2,7 +2,7 @@ using System.IO; using System.Text; -namespace MoonSharp.Interpreter.Platforms +namespace WattleScript.Interpreter.Platforms { /// /// An abstract class which offers basic services on top of IPlatformAccessor to provide easier implementation of platforms. diff --git a/src/MoonSharp.Interpreter/Platforms/PlatformAutoDetector.cs b/src/WattleScript.Interpreter/Platforms/PlatformAutoDetector.cs similarity index 95% rename from src/MoonSharp.Interpreter/Platforms/PlatformAutoDetector.cs rename to src/WattleScript.Interpreter/Platforms/PlatformAutoDetector.cs index 9d1c2699..10d61c23 100755 --- a/src/MoonSharp.Interpreter/Platforms/PlatformAutoDetector.cs +++ b/src/WattleScript.Interpreter/Platforms/PlatformAutoDetector.cs @@ -1,9 +1,9 @@ using System; using System.Linq; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Loaders; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Loaders; -namespace MoonSharp.Interpreter.Platforms +namespace WattleScript.Interpreter.Platforms { /// /// A static class offering properties for autodetection of system/platform details diff --git a/src/MoonSharp.Interpreter/Platforms/StandardFileType.cs b/src/WattleScript.Interpreter/Platforms/StandardFileType.cs similarity index 87% rename from src/MoonSharp.Interpreter/Platforms/StandardFileType.cs rename to src/WattleScript.Interpreter/Platforms/StandardFileType.cs index 4e15df3d..1ec584d5 100644 --- a/src/MoonSharp.Interpreter/Platforms/StandardFileType.cs +++ b/src/WattleScript.Interpreter/Platforms/StandardFileType.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Platforms +namespace WattleScript.Interpreter.Platforms { /// /// Enumeration of standard file handles diff --git a/src/MoonSharp.Interpreter/Platforms/StandardPlatformAccessor.cs b/src/WattleScript.Interpreter/Platforms/StandardPlatformAccessor.cs similarity index 98% rename from src/MoonSharp.Interpreter/Platforms/StandardPlatformAccessor.cs rename to src/WattleScript.Interpreter/Platforms/StandardPlatformAccessor.cs index fae7c2e1..910f62cc 100755 --- a/src/MoonSharp.Interpreter/Platforms/StandardPlatformAccessor.cs +++ b/src/WattleScript.Interpreter/Platforms/StandardPlatformAccessor.cs @@ -4,7 +4,7 @@ using System.IO; using System.Text; -namespace MoonSharp.Interpreter.Platforms +namespace WattleScript.Interpreter.Platforms { /// /// Class providing the IPlatformAccessor interface for standard full-feaured implementations. @@ -78,7 +78,7 @@ public override void OS_FileMove(string src, string dst) using System.IO; using System.Text; -namespace MoonSharp.Interpreter.Platforms +namespace WattleScript.Interpreter.Platforms { /// /// Class providing the IPlatformAccessor interface for standard full-feaured implementations. diff --git a/src/MoonSharp.Interpreter/REPL/ReplHistoryNavigator.cs b/src/WattleScript.Interpreter/REPL/ReplHistoryNavigator.cs similarity index 97% rename from src/MoonSharp.Interpreter/REPL/ReplHistoryNavigator.cs rename to src/WattleScript.Interpreter/REPL/ReplHistoryNavigator.cs index 61fb7ce0..3cc6f6f0 100644 --- a/src/MoonSharp.Interpreter/REPL/ReplHistoryNavigator.cs +++ b/src/WattleScript.Interpreter/REPL/ReplHistoryNavigator.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.REPL +namespace WattleScript.Interpreter.REPL { /// /// An implementation of which supports a very basic history of recent input lines. diff --git a/src/MoonSharp.Interpreter/REPL/ReplInterpreter.cs b/src/WattleScript.Interpreter/REPL/ReplInterpreter.cs similarity index 98% rename from src/MoonSharp.Interpreter/REPL/ReplInterpreter.cs rename to src/WattleScript.Interpreter/REPL/ReplInterpreter.cs index dea27ac2..de2c0d46 100644 --- a/src/MoonSharp.Interpreter/REPL/ReplInterpreter.cs +++ b/src/WattleScript.Interpreter/REPL/ReplInterpreter.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.REPL +namespace WattleScript.Interpreter.REPL { /// /// This class provides a simple REPL intepreter ready to be reused in a simple way. diff --git a/src/MoonSharp.Interpreter/REPL/ReplInterpreterScriptLoader.cs b/src/WattleScript.Interpreter/REPL/ReplInterpreterScriptLoader.cs similarity index 96% rename from src/MoonSharp.Interpreter/REPL/ReplInterpreterScriptLoader.cs rename to src/WattleScript.Interpreter/REPL/ReplInterpreterScriptLoader.cs index bc324054..0b7b702e 100755 --- a/src/MoonSharp.Interpreter/REPL/ReplInterpreterScriptLoader.cs +++ b/src/WattleScript.Interpreter/REPL/ReplInterpreterScriptLoader.cs @@ -1,7 +1,7 @@ using System; -using MoonSharp.Interpreter.Loaders; +using WattleScript.Interpreter.Loaders; -namespace MoonSharp.Interpreter.REPL +namespace WattleScript.Interpreter.REPL { /// /// A script loader loading scripts directly from the file system (does not go through platform object) diff --git a/src/MoonSharp.Interpreter/Script.cs b/src/WattleScript.Interpreter/Script.cs similarity index 92% rename from src/MoonSharp.Interpreter/Script.cs rename to src/WattleScript.Interpreter/Script.cs index 000b803e..eb829003 100755 --- a/src/MoonSharp.Interpreter/Script.cs +++ b/src/WattleScript.Interpreter/Script.cs @@ -4,22 +4,22 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -using MoonSharp.Interpreter.CoreLib; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Diagnostics; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.IO; -using MoonSharp.Interpreter.Platforms; -using MoonSharp.Interpreter.Tree; -using MoonSharp.Interpreter.Tree.Expressions; -using MoonSharp.Interpreter.Tree.Fast_Interface; - -namespace MoonSharp.Interpreter +using WattleScript.Interpreter.CoreLib; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Diagnostics; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.IO; +using WattleScript.Interpreter.Platforms; +using WattleScript.Interpreter.Tree; +using WattleScript.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Tree.Fast_Interface; + +namespace WattleScript.Interpreter { /// - /// This class implements a MoonSharp scripting session. Multiple Script objects can coexist in the same program but cannot share + /// This class implements a WattleScript scripting session. Multiple Script objects can coexist in the same program but cannot share /// data among themselves unless some mechanism is put in place. /// public class Script : IScriptPrivateResource @@ -51,7 +51,7 @@ internal ScriptParserMessage(Token token, string msg) } /// - /// The version of the MoonSharp engine + /// The version of the WattleScript engine /// public const string VERSION = "3.0.0.0"; @@ -140,7 +140,7 @@ public Table Globals } /// - /// Loads a string containing a Lua/MoonSharp function. + /// Loads a string containing a Lua/WattleScript function. /// /// The code. /// The global table to bind to this chunk. @@ -184,7 +184,7 @@ private void SignalSourceCodeChange(SourceCode source) /// - /// Loads a string containing a Lua/MoonSharp script. + /// Loads a string containing a Lua/WattleScript script. /// /// The code. /// The global table to bind to this chunk. @@ -221,7 +221,7 @@ public DynValue LoadString(string code, Table globalTable = null, string codeFri } /// - /// Loads a Lua/MoonSharp script from a System.IO.Stream. NOTE: This will *NOT* close the stream! + /// Loads a Lua/WattleScript script from a System.IO.Stream. NOTE: This will *NOT* close the stream! /// /// The stream containing code. /// The global table to bind to this chunk. @@ -311,7 +311,7 @@ public string DumpString(DynValue function) /// - /// Loads a string containing a Lua/MoonSharp script. + /// Loads a string containing a Lua/WattleScript script. /// /// The code. /// The global table to bind to this chunk. @@ -360,7 +360,7 @@ public DynValue LoadFile(string filename, Table globalContext = null, string fri /// - /// Loads and executes a string containing a Lua/MoonSharp script. + /// Loads and executes a string containing a Lua/WattleScript script. /// /// The code. /// The global context. @@ -382,7 +382,7 @@ public Task DoStringAsync(string code, Table globalContext = null, str /// - /// Loads and executes a stream containing a Lua/MoonSharp script. + /// Loads and executes a stream containing a Lua/WattleScript script. /// /// The stream. /// The global context. @@ -398,7 +398,7 @@ public DynValue DoStream(Stream stream, Table globalContext = null, string codeF /// - /// Loads and executes a file containing a Lua/MoonSharp script. + /// Loads and executes a file containing a Lua/WattleScript script. /// /// The filename. /// The global context. @@ -427,7 +427,7 @@ public static DynValue RunFile(string filename) /// /// Runs the specified code with all possible defaults for quick experimenting. /// - /// The Lua/MoonSharp code. + /// The Lua/WattleScript code. /// A DynValue containing the result of the processing of the executed script. public static DynValue RunString(string code) { @@ -481,7 +481,7 @@ private DynValue MakeClosure(int address, Table envTable = null) /// /// Calls the specified function. /// - /// The Lua/MoonSharp function to be called + /// The Lua/WattleScript function to be called /// /// The return value(s) of the function call. /// @@ -499,7 +499,7 @@ public Task CallAsync(DynValue function) /// /// Calls the specified function. /// - /// The Lua/MoonSharp function to be called + /// The Lua/WattleScript function to be called /// The arguments to pass to the function. /// /// The return value(s) of the function call. @@ -573,7 +573,7 @@ public Task CallAsync(DynValue function, params DynValue[] args) /// /// Calls the specified function. /// - /// The Lua/MoonSharp function to be called + /// The Lua/WattleScript function to be called /// The arguments to pass to the function. /// /// The return value(s) of the function call. @@ -592,7 +592,7 @@ public DynValue Call(DynValue function, params object[] args) /// /// Calls the specified function. /// - /// The Lua/MoonSharp function to be called + /// The Lua/WattleScript function to be called /// /// Thrown if function is not of DataType.Function public DynValue Call(object function) @@ -603,7 +603,7 @@ public DynValue Call(object function) /// /// Calls the specified function. /// - /// The Lua/MoonSharp function to be called + /// The Lua/WattleScript function to be called /// The arguments to pass to the function. /// /// Thrown if function is not of DataType.Function @@ -615,7 +615,7 @@ public DynValue Call(object function, params object[] args) /// /// Calls the specified function. /// - /// The Lua/MoonSharp function to be called + /// The Lua/WattleScript function to be called /// The arguments to pass to the function. /// /// Thrown if function is not of DataType.Function @@ -791,7 +791,7 @@ public void SetTypeMetatable(DataType type, Table metatable) /// - /// Warms up the parser/lexer structures so that MoonSharp operations start faster. + /// Warms up the parser/lexer structures so that WattleScript operations start faster. /// public static void WarmUp() { @@ -835,7 +835,7 @@ internal ScriptExecutionContext CreateDynamicExecutionContext(CallbackFunction f } /// - /// MoonSharp (like Lua itself) provides a registry, a predefined table that can be used by any CLR code to + /// WattleScript (like Lua itself) provides a registry, a predefined table that can be used by any CLR code to /// store whatever Lua values it needs to store. /// Any CLR code can store data into this table, but it should take care to choose keys /// that are different from those used by other libraries, to avoid collisions. @@ -856,9 +856,9 @@ public static string GetBanner(string subproduct = null) subproduct = (subproduct != null) ? (subproduct + " ") : ""; StringBuilder sb = new StringBuilder(); - sb.AppendLine(string.Format("MoonSharp {0}{1} [{2}]", subproduct, Script.VERSION, Script.GlobalOptions.Platform.GetPlatformName())); - sb.AppendLine("Copyright (C) 2014-2022 MoonSharp Contributors"); - sb.AppendLine("http://www.moonsharp.org"); + sb.AppendLine(string.Format("WattleScript {0}{1} [{2}]", subproduct, Script.VERSION, Script.GlobalOptions.Platform.GetPlatformName())); + sb.AppendLine("Copyright (C) 2014-2022 WattleScript Contributors"); + sb.AppendLine("http://www.wattlescript.org"); return sb.ToString(); } diff --git a/src/MoonSharp.Interpreter/ScriptGlobalOptions.cs b/src/WattleScript.Interpreter/ScriptGlobalOptions.cs similarity index 91% rename from src/MoonSharp.Interpreter/ScriptGlobalOptions.cs rename to src/WattleScript.Interpreter/ScriptGlobalOptions.cs index 3544c703..27db9005 100644 --- a/src/MoonSharp.Interpreter/ScriptGlobalOptions.cs +++ b/src/WattleScript.Interpreter/ScriptGlobalOptions.cs @@ -1,8 +1,8 @@ -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Platforms; -using MoonSharp.Interpreter; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Platforms; +using WattleScript.Interpreter; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// Class containing script global options, that is options which cannot be customized per-script. diff --git a/src/MoonSharp.Interpreter/ScriptOptions.cs b/src/WattleScript.Interpreter/ScriptOptions.cs similarity index 91% rename from src/MoonSharp.Interpreter/ScriptOptions.cs rename to src/WattleScript.Interpreter/ScriptOptions.cs index a95656d8..cc709620 100644 --- a/src/MoonSharp.Interpreter/ScriptOptions.cs +++ b/src/WattleScript.Interpreter/ScriptOptions.cs @@ -1,9 +1,9 @@ using System; using System.Collections.Generic; using System.IO; -using MoonSharp.Interpreter.Loaders; +using WattleScript.Interpreter.Loaders; -namespace MoonSharp.Interpreter +namespace WattleScript.Interpreter { /// /// This class contains options to customize behaviour of Script objects. @@ -52,7 +52,7 @@ public enum ParserErrorModes public Func DebugInput { get; set; } /// - /// Gets or sets a value indicating whether error messages will use Lua error locations instead of MoonSharp + /// Gets or sets a value indicating whether error messages will use Lua error locations instead of WattleScript /// improved ones. Use this for compatibility with legacy Lua code which parses error messages. /// public bool UseLuaErrorLocations { get; set; } @@ -78,11 +78,11 @@ public enum ParserErrorModes public Stream Stderr { get; set; } /// - /// Gets or sets the stack depth threshold at which MoonSharp starts doing + /// Gets or sets the stack depth threshold at which WattleScript starts doing /// tail call optimizations. /// TCOs can provide the little benefit of avoiding stack overflows in corner case /// scenarios, at the expense of losing debug information and error stack traces - /// in all other, more common scenarios. MoonSharp choice is to start performing + /// in all other, more common scenarios. WattleScript choice is to start performing /// TCOs only after a certain threshold of stack usage is reached - by default /// half the current stack depth (128K entries), thus 64K entries, on either /// the internal stacks. @@ -94,12 +94,12 @@ public enum ParserErrorModes /// /// Gets or sets a value indicating whether the thread check is enabled. /// A "lazy" thread check is performed everytime execution is entered to ensure that no two threads - /// calls MoonSharp execution concurrently. However 1) the check is performed best effort (thus, it might + /// calls WattleScript execution concurrently. However 1) the check is performed best effort (thus, it might /// not detect all issues) and 2) it might trigger in very odd legal situations (like, switching threads /// inside a CLR-callback without actually having concurrency. /// /// Disable this option if the thread check is giving problems in your scenario, but please check that - /// you are not calling MoonSharp execution concurrently as it is not supported. + /// you are not calling WattleScript execution concurrently as it is not supported. /// public bool CheckThreadAccess { get; set; } diff --git a/src/MoonSharp.Interpreter/Serialization/Json/JsonNull.cs b/src/WattleScript.Interpreter/Serialization/Json/JsonNull.cs similarity index 84% rename from src/MoonSharp.Interpreter/Serialization/Json/JsonNull.cs rename to src/WattleScript.Interpreter/Serialization/Json/JsonNull.cs index 0c1e7490..51f972f8 100755 --- a/src/MoonSharp.Interpreter/Serialization/Json/JsonNull.cs +++ b/src/WattleScript.Interpreter/Serialization/Json/JsonNull.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Interpreter.Serialization.Json +namespace WattleScript.Interpreter.Serialization.Json { /// /// UserData representing a null value in a table converted from Json @@ -12,7 +12,7 @@ public sealed class JsonNull { public static bool isNull() { return true; } - [MoonSharpHidden] + [WattleScriptHidden] public static bool IsJsonNull(DynValue v) { return v.Type == DataType.UserData && @@ -20,7 +20,7 @@ public static bool IsJsonNull(DynValue v) v.UserData.Descriptor.Type == typeof(JsonNull); } - [MoonSharpHidden] + [WattleScriptHidden] public static DynValue Create() { return UserData.CreateStatic(); diff --git a/src/MoonSharp.Interpreter/Serialization/Json/JsonTableConverter.cs b/src/WattleScript.Interpreter/Serialization/Json/JsonTableConverter.cs similarity index 98% rename from src/MoonSharp.Interpreter/Serialization/Json/JsonTableConverter.cs rename to src/WattleScript.Interpreter/Serialization/Json/JsonTableConverter.cs index 7f1e89a6..e950619d 100755 --- a/src/MoonSharp.Interpreter/Serialization/Json/JsonTableConverter.cs +++ b/src/WattleScript.Interpreter/Serialization/Json/JsonTableConverter.cs @@ -2,9 +2,9 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Tree; +using WattleScript.Interpreter.Tree; -namespace MoonSharp.Interpreter.Serialization.Json +namespace WattleScript.Interpreter.Serialization.Json { /// /// Class performing conversions between Tables and Json. diff --git a/src/MoonSharp.Interpreter/Serialization/ObjectValueConverter.cs b/src/WattleScript.Interpreter/Serialization/ObjectValueConverter.cs similarity index 89% rename from src/MoonSharp.Interpreter/Serialization/ObjectValueConverter.cs rename to src/WattleScript.Interpreter/Serialization/ObjectValueConverter.cs index a4ba0c00..8b08e818 100755 --- a/src/MoonSharp.Interpreter/Serialization/ObjectValueConverter.cs +++ b/src/WattleScript.Interpreter/Serialization/ObjectValueConverter.cs @@ -3,10 +3,10 @@ using System.Linq; using System.Reflection; using System.Text; -using MoonSharp.Interpreter.Interop.Converters; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.Interop.Converters; +using WattleScript.Interpreter.Interop; -namespace MoonSharp.Interpreter.Serialization +namespace WattleScript.Interpreter.Serialization { public static class ObjectValueConverter { diff --git a/src/MoonSharp.Interpreter/Serialization/SerializationExtensions.cs b/src/WattleScript.Interpreter/Serialization/SerializationExtensions.cs similarity index 98% rename from src/MoonSharp.Interpreter/Serialization/SerializationExtensions.cs rename to src/WattleScript.Interpreter/Serialization/SerializationExtensions.cs index af2db8c3..56f97a02 100755 --- a/src/MoonSharp.Interpreter/Serialization/SerializationExtensions.cs +++ b/src/WattleScript.Interpreter/Serialization/SerializationExtensions.cs @@ -2,7 +2,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Interpreter.Serialization +namespace WattleScript.Interpreter.Serialization { /// /// diff --git a/src/MoonSharp.Interpreter/Tree/Expression_.cs b/src/WattleScript.Interpreter/Tree/Expression_.cs similarity index 97% rename from src/MoonSharp.Interpreter/Tree/Expression_.cs rename to src/WattleScript.Interpreter/Tree/Expression_.cs index 09b94024..29e13f41 100644 --- a/src/MoonSharp.Interpreter/Tree/Expression_.cs +++ b/src/WattleScript.Interpreter/Tree/Expression_.cs @@ -1,11 +1,11 @@ using System; using System.Collections.Generic; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Tree.Expressions; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree +namespace WattleScript.Interpreter.Tree { abstract class Expression : NodeBase { diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/AdjustmentExpression.cs b/src/WattleScript.Interpreter/Tree/Expressions/AdjustmentExpression.cs similarity index 83% rename from src/MoonSharp.Interpreter/Tree/Expressions/AdjustmentExpression.cs rename to src/WattleScript.Interpreter/Tree/Expressions/AdjustmentExpression.cs index b7b49873..419e87b9 100644 --- a/src/MoonSharp.Interpreter/Tree/Expressions/AdjustmentExpression.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/AdjustmentExpression.cs @@ -1,8 +1,8 @@ -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Execution; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { class AdjustmentExpression : Expression { diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/BinaryOperatorExpression.cs b/src/WattleScript.Interpreter/Tree/Expressions/BinaryOperatorExpression.cs similarity index 98% rename from src/MoonSharp.Interpreter/Tree/Expressions/BinaryOperatorExpression.cs rename to src/WattleScript.Interpreter/Tree/Expressions/BinaryOperatorExpression.cs index a31699f4..14c6b1a8 100755 --- a/src/MoonSharp.Interpreter/Tree/Expressions/BinaryOperatorExpression.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/BinaryOperatorExpression.cs @@ -1,9 +1,9 @@ using System; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { [Flags] public enum Operator diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/DynamicExprExpression.cs b/src/WattleScript.Interpreter/Tree/Expressions/DynamicExprExpression.cs similarity index 85% rename from src/MoonSharp.Interpreter/Tree/Expressions/DynamicExprExpression.cs rename to src/WattleScript.Interpreter/Tree/Expressions/DynamicExprExpression.cs index 17389d75..b879182f 100644 --- a/src/MoonSharp.Interpreter/Tree/Expressions/DynamicExprExpression.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/DynamicExprExpression.cs @@ -1,8 +1,8 @@ using System; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Execution; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { class DynamicExprExpression : Expression { diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/ExprListExpression.cs b/src/WattleScript.Interpreter/Tree/Expressions/ExprListExpression.cs similarity index 87% rename from src/MoonSharp.Interpreter/Tree/Expressions/ExprListExpression.cs rename to src/WattleScript.Interpreter/Tree/Expressions/ExprListExpression.cs index 33d10f35..5394f8f8 100644 --- a/src/MoonSharp.Interpreter/Tree/Expressions/ExprListExpression.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/ExprListExpression.cs @@ -1,8 +1,8 @@ using System.Collections.Generic; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Execution; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { class ExprListExpression : Expression { diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/FunctionCallExpression.cs b/src/WattleScript.Interpreter/Tree/Expressions/FunctionCallExpression.cs similarity index 94% rename from src/MoonSharp.Interpreter/Tree/Expressions/FunctionCallExpression.cs rename to src/WattleScript.Interpreter/Tree/Expressions/FunctionCallExpression.cs index 99948a70..8740007b 100644 --- a/src/MoonSharp.Interpreter/Tree/Expressions/FunctionCallExpression.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/FunctionCallExpression.cs @@ -1,9 +1,9 @@ using System.Collections.Generic; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { class FunctionCallExpression : Expression { diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/FunctionDefinitionExpression.cs b/src/WattleScript.Interpreter/Tree/Expressions/FunctionDefinitionExpression.cs similarity index 97% rename from src/MoonSharp.Interpreter/Tree/Expressions/FunctionDefinitionExpression.cs rename to src/WattleScript.Interpreter/Tree/Expressions/FunctionDefinitionExpression.cs index db884c5a..be8c7de2 100644 --- a/src/MoonSharp.Interpreter/Tree/Expressions/FunctionDefinitionExpression.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/FunctionDefinitionExpression.cs @@ -1,13 +1,13 @@ using System; using System.Collections.Generic; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -using MoonSharp.Interpreter.Tree.Statements; +using WattleScript.Interpreter.Tree.Statements; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { class FunctionDefinitionExpression : Expression, IClosureBuilder { diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/IndexExpression.cs b/src/WattleScript.Interpreter/Tree/Expressions/IndexExpression.cs similarity index 96% rename from src/MoonSharp.Interpreter/Tree/Expressions/IndexExpression.cs rename to src/WattleScript.Interpreter/Tree/Expressions/IndexExpression.cs index d46e7397..309d7b52 100644 --- a/src/MoonSharp.Interpreter/Tree/Expressions/IndexExpression.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/IndexExpression.cs @@ -1,9 +1,9 @@ using System; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { class IndexExpression : Expression, IVariable { diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/LiteralExpression.cs b/src/WattleScript.Interpreter/Tree/Expressions/LiteralExpression.cs similarity index 91% rename from src/MoonSharp.Interpreter/Tree/Expressions/LiteralExpression.cs rename to src/WattleScript.Interpreter/Tree/Expressions/LiteralExpression.cs index a5c67534..e1b7d3b5 100644 --- a/src/MoonSharp.Interpreter/Tree/Expressions/LiteralExpression.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/LiteralExpression.cs @@ -1,7 +1,7 @@ -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Execution; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { class LiteralExpression : Expression { diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/SymbolRefExpression.cs b/src/WattleScript.Interpreter/Tree/Expressions/SymbolRefExpression.cs similarity index 93% rename from src/MoonSharp.Interpreter/Tree/Expressions/SymbolRefExpression.cs rename to src/WattleScript.Interpreter/Tree/Expressions/SymbolRefExpression.cs index c47c3020..5a60ab52 100644 --- a/src/MoonSharp.Interpreter/Tree/Expressions/SymbolRefExpression.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/SymbolRefExpression.cs @@ -1,9 +1,9 @@ using System; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { class SymbolRefExpression : Expression, IVariable { diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/TableConstructor.cs b/src/WattleScript.Interpreter/Tree/Expressions/TableConstructor.cs similarity index 97% rename from src/MoonSharp.Interpreter/Tree/Expressions/TableConstructor.cs rename to src/WattleScript.Interpreter/Tree/Expressions/TableConstructor.cs index 6b3be816..e4af857f 100644 --- a/src/MoonSharp.Interpreter/Tree/Expressions/TableConstructor.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/TableConstructor.cs @@ -1,8 +1,8 @@ using System.Collections.Generic; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Execution; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { class TableConstructor : Expression { diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/TemplatedStringExpression.cs b/src/WattleScript.Interpreter/Tree/Expressions/TemplatedStringExpression.cs similarity index 95% rename from src/MoonSharp.Interpreter/Tree/Expressions/TemplatedStringExpression.cs rename to src/WattleScript.Interpreter/Tree/Expressions/TemplatedStringExpression.cs index 7725c19f..07050652 100644 --- a/src/MoonSharp.Interpreter/Tree/Expressions/TemplatedStringExpression.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/TemplatedStringExpression.cs @@ -1,10 +1,10 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { class TemplatedStringExpression : Expression { diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/TernaryExpression.cs b/src/WattleScript.Interpreter/Tree/Expressions/TernaryExpression.cs similarity index 94% rename from src/MoonSharp.Interpreter/Tree/Expressions/TernaryExpression.cs rename to src/WattleScript.Interpreter/Tree/Expressions/TernaryExpression.cs index c1e10291..125bca8b 100644 --- a/src/MoonSharp.Interpreter/Tree/Expressions/TernaryExpression.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/TernaryExpression.cs @@ -1,8 +1,8 @@ using System; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { class TernaryExpression : Expression { diff --git a/src/MoonSharp.Interpreter/Tree/Expressions/UnaryOperatorExpression.cs b/src/WattleScript.Interpreter/Tree/Expressions/UnaryOperatorExpression.cs similarity index 95% rename from src/MoonSharp.Interpreter/Tree/Expressions/UnaryOperatorExpression.cs rename to src/WattleScript.Interpreter/Tree/Expressions/UnaryOperatorExpression.cs index 442ce024..045795a2 100644 --- a/src/MoonSharp.Interpreter/Tree/Expressions/UnaryOperatorExpression.cs +++ b/src/WattleScript.Interpreter/Tree/Expressions/UnaryOperatorExpression.cs @@ -1,9 +1,9 @@ using System; -using MoonSharp.Interpreter.DataStructs; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.DataStructs; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Expressions +namespace WattleScript.Interpreter.Tree.Expressions { class UnaryOperatorExpression : Expression { diff --git a/src/MoonSharp.Interpreter/Tree/Fast_Interface/Loader_Fast.cs b/src/WattleScript.Interpreter/Tree/Fast_Interface/Loader_Fast.cs similarity index 92% rename from src/MoonSharp.Interpreter/Tree/Fast_Interface/Loader_Fast.cs rename to src/WattleScript.Interpreter/Tree/Fast_Interface/Loader_Fast.cs index f3eeac05..9db8f821 100644 --- a/src/MoonSharp.Interpreter/Tree/Fast_Interface/Loader_Fast.cs +++ b/src/WattleScript.Interpreter/Tree/Fast_Interface/Loader_Fast.cs @@ -1,10 +1,10 @@ -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; -using MoonSharp.Interpreter.Tree.Expressions; -using MoonSharp.Interpreter.Tree.Statements; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; +using WattleScript.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Tree.Statements; -namespace MoonSharp.Interpreter.Tree.Fast_Interface +namespace WattleScript.Interpreter.Tree.Fast_Interface { internal static class Loader_Fast { diff --git a/src/MoonSharp.Interpreter/Tree/IVariable.cs b/src/WattleScript.Interpreter/Tree/IVariable.cs similarity index 64% rename from src/MoonSharp.Interpreter/Tree/IVariable.cs rename to src/WattleScript.Interpreter/Tree/IVariable.cs index fa1e15c7..4dca0453 100644 --- a/src/MoonSharp.Interpreter/Tree/IVariable.cs +++ b/src/WattleScript.Interpreter/Tree/IVariable.cs @@ -1,7 +1,7 @@  -using MoonSharp.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Tree.Expressions; -namespace MoonSharp.Interpreter.Tree +namespace WattleScript.Interpreter.Tree { interface IVariable { diff --git a/src/MoonSharp.Interpreter/Tree/Lexer/Lexer.cs b/src/WattleScript.Interpreter/Tree/Lexer/Lexer.cs similarity index 99% rename from src/MoonSharp.Interpreter/Tree/Lexer/Lexer.cs rename to src/WattleScript.Interpreter/Tree/Lexer/Lexer.cs index 6193cf3e..c1d20ddf 100755 --- a/src/MoonSharp.Interpreter/Tree/Lexer/Lexer.cs +++ b/src/WattleScript.Interpreter/Tree/Lexer/Lexer.cs @@ -2,7 +2,7 @@ using System.Collections.Generic; using System.Text; -namespace MoonSharp.Interpreter.Tree +namespace WattleScript.Interpreter.Tree { class Lexer { diff --git a/src/MoonSharp.Interpreter/Tree/Lexer/LexerUtils.cs b/src/WattleScript.Interpreter/Tree/Lexer/LexerUtils.cs similarity index 99% rename from src/MoonSharp.Interpreter/Tree/Lexer/LexerUtils.cs rename to src/WattleScript.Interpreter/Tree/Lexer/LexerUtils.cs index d7802bbb..a7fe9fd0 100755 --- a/src/MoonSharp.Interpreter/Tree/Lexer/LexerUtils.cs +++ b/src/WattleScript.Interpreter/Tree/Lexer/LexerUtils.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Interpreter.Tree +namespace WattleScript.Interpreter.Tree { internal static class LexerUtils { diff --git a/src/MoonSharp.Interpreter/Tree/Lexer/Token.cs b/src/WattleScript.Interpreter/Tree/Lexer/Token.cs similarity index 99% rename from src/MoonSharp.Interpreter/Tree/Lexer/Token.cs rename to src/WattleScript.Interpreter/Tree/Lexer/Token.cs index 275135a9..bc2900cf 100644 --- a/src/MoonSharp.Interpreter/Tree/Lexer/Token.cs +++ b/src/WattleScript.Interpreter/Tree/Lexer/Token.cs @@ -1,6 +1,6 @@ using System; -namespace MoonSharp.Interpreter.Tree +namespace WattleScript.Interpreter.Tree { class Token { diff --git a/src/MoonSharp.Interpreter/Tree/Lexer/TokenType.cs b/src/WattleScript.Interpreter/Tree/Lexer/TokenType.cs similarity index 97% rename from src/MoonSharp.Interpreter/Tree/Lexer/TokenType.cs rename to src/WattleScript.Interpreter/Tree/Lexer/TokenType.cs index aef1f733..207d9a31 100644 --- a/src/MoonSharp.Interpreter/Tree/Lexer/TokenType.cs +++ b/src/WattleScript.Interpreter/Tree/Lexer/TokenType.cs @@ -1,5 +1,5 @@  -namespace MoonSharp.Interpreter.Tree +namespace WattleScript.Interpreter.Tree { enum TokenType { diff --git a/src/MoonSharp.Interpreter/Tree/Loop.cs b/src/WattleScript.Interpreter/Tree/Loop.cs similarity index 86% rename from src/MoonSharp.Interpreter/Tree/Loop.cs rename to src/WattleScript.Interpreter/Tree/Loop.cs index ffd4428d..13242043 100644 --- a/src/MoonSharp.Interpreter/Tree/Loop.cs +++ b/src/WattleScript.Interpreter/Tree/Loop.cs @@ -1,8 +1,8 @@ using System.Collections.Generic; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree +namespace WattleScript.Interpreter.Tree { internal class Loop : ILoop { diff --git a/src/MoonSharp.Interpreter/Tree/NodeBase.cs b/src/WattleScript.Interpreter/Tree/NodeBase.cs similarity index 95% rename from src/MoonSharp.Interpreter/Tree/NodeBase.cs rename to src/WattleScript.Interpreter/Tree/NodeBase.cs index 93b31778..5ed781ba 100644 --- a/src/MoonSharp.Interpreter/Tree/NodeBase.cs +++ b/src/WattleScript.Interpreter/Tree/NodeBase.cs @@ -1,7 +1,7 @@ -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree +namespace WattleScript.Interpreter.Tree { abstract class NodeBase { diff --git a/src/MoonSharp.Interpreter/Tree/Statement.cs b/src/WattleScript.Interpreter/Tree/Statement.cs similarity index 98% rename from src/MoonSharp.Interpreter/Tree/Statement.cs rename to src/WattleScript.Interpreter/Tree/Statement.cs index 93931779..a5d2edab 100644 --- a/src/MoonSharp.Interpreter/Tree/Statement.cs +++ b/src/WattleScript.Interpreter/Tree/Statement.cs @@ -1,9 +1,9 @@ using System; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Tree.Expressions; -using MoonSharp.Interpreter.Tree.Statements; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Tree.Statements; -namespace MoonSharp.Interpreter.Tree +namespace WattleScript.Interpreter.Tree { abstract class Statement : NodeBase { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/AssignmentStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/AssignmentStatement.cs similarity index 96% rename from src/MoonSharp.Interpreter/Tree/Statements/AssignmentStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/AssignmentStatement.cs index ff2b7e74..b8496a26 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/AssignmentStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/AssignmentStatement.cs @@ -1,12 +1,12 @@ using System; using System.Collections.Generic; using System.Linq; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; -using MoonSharp.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Tree.Expressions; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class AssignmentStatement : Statement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/BreakStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/BreakStatement.cs similarity index 81% rename from src/MoonSharp.Interpreter/Tree/Statements/BreakStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/BreakStatement.cs index 9d7685cc..f27dc680 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/BreakStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/BreakStatement.cs @@ -1,9 +1,9 @@ -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class BreakStatement : Statement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/CStyleForStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/CStyleForStatement.cs similarity index 96% rename from src/MoonSharp.Interpreter/Tree/Statements/CStyleForStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/CStyleForStatement.cs index d46b6ef3..3bc8e1cf 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/CStyleForStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/CStyleForStatement.cs @@ -1,10 +1,10 @@ using System.Runtime.Serialization; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; -using MoonSharp.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; +using WattleScript.Interpreter.Tree.Expressions; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class CStyleForStatement : Statement, IBlockStatement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/ChunkStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/ChunkStatement.cs similarity index 92% rename from src/MoonSharp.Interpreter/Tree/Statements/ChunkStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/ChunkStatement.cs index c0da8055..d6615c48 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/ChunkStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/ChunkStatement.cs @@ -1,8 +1,8 @@ using System; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class ChunkStatement : Statement, IClosureBuilder { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/CompositeStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/CompositeStatement.cs similarity index 97% rename from src/MoonSharp.Interpreter/Tree/Statements/CompositeStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/CompositeStatement.cs index e3673e48..08a2b7aa 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/CompositeStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/CompositeStatement.cs @@ -1,10 +1,10 @@ using System; using System.Collections.Generic; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Execution; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { enum BlockEndType { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/ContinueStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/ContinueStatement.cs similarity index 85% rename from src/MoonSharp.Interpreter/Tree/Statements/ContinueStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/ContinueStatement.cs index 51248b7d..5e0a7470 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/ContinueStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/ContinueStatement.cs @@ -1,9 +1,9 @@ -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class ContinueStatement : Statement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/DoBlockStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/DoBlockStatement.cs similarity index 92% rename from src/MoonSharp.Interpreter/Tree/Statements/DoBlockStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/DoBlockStatement.cs index 175790c0..3767ffcf 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/DoBlockStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/DoBlockStatement.cs @@ -1,8 +1,8 @@ -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class DoBlockStatement : Statement, IBlockStatement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/EmptyStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/EmptyStatement.cs similarity index 74% rename from src/MoonSharp.Interpreter/Tree/Statements/EmptyStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/EmptyStatement.cs index 6ffdd54d..c0ea11d2 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/EmptyStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/EmptyStatement.cs @@ -1,6 +1,6 @@ -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Execution; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class EmptyStatement : Statement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/ForEachLoopStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/ForEachLoopStatement.cs similarity index 95% rename from src/MoonSharp.Interpreter/Tree/Statements/ForEachLoopStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/ForEachLoopStatement.cs index 61284555..e6cc6886 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/ForEachLoopStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/ForEachLoopStatement.cs @@ -1,12 +1,12 @@ using System.Collections.Generic; using System.Linq; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -using MoonSharp.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Tree.Expressions; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class ForEachLoopStatement : Statement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/ForLoopStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/ForLoopStatement.cs similarity index 93% rename from src/MoonSharp.Interpreter/Tree/Statements/ForLoopStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/ForLoopStatement.cs index 3c412ca4..3ff9bddd 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/ForLoopStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/ForLoopStatement.cs @@ -1,10 +1,10 @@ -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -using MoonSharp.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Tree.Expressions; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class ForLoopStatement : Statement, IBlockStatement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/ForRangeStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/ForRangeStatement.cs similarity index 94% rename from src/MoonSharp.Interpreter/Tree/Statements/ForRangeStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/ForRangeStatement.cs index 6a82d639..642775a8 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/ForRangeStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/ForRangeStatement.cs @@ -1,10 +1,10 @@ -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -using MoonSharp.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Tree.Expressions; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class ForRangeStatement : Statement, IBlockStatement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/FunctionCallStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/FunctionCallStatement.cs similarity index 80% rename from src/MoonSharp.Interpreter/Tree/Statements/FunctionCallStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/FunctionCallStatement.cs index 16a30e2f..9fdf5899 100755 --- a/src/MoonSharp.Interpreter/Tree/Statements/FunctionCallStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/FunctionCallStatement.cs @@ -1,9 +1,9 @@ using System; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; -using MoonSharp.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; +using WattleScript.Interpreter.Tree.Expressions; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class FunctionCallStatement : Statement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/FunctionDefinitionStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/FunctionDefinitionStatement.cs similarity index 95% rename from src/MoonSharp.Interpreter/Tree/Statements/FunctionDefinitionStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/FunctionDefinitionStatement.cs index 8c65777d..de1d49cf 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/FunctionDefinitionStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/FunctionDefinitionStatement.cs @@ -1,10 +1,10 @@ using System.Collections.Generic; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; -using MoonSharp.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Tree.Expressions; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class FunctionDefinitionStatement : Statement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/GotoStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/GotoStatement.cs similarity index 86% rename from src/MoonSharp.Interpreter/Tree/Statements/GotoStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/GotoStatement.cs index 4449ff6d..e35768d2 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/GotoStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/GotoStatement.cs @@ -1,8 +1,8 @@ -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class GotoStatement : Statement { diff --git a/src/WattleScript.Interpreter/Tree/Statements/IBlockStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/IBlockStatement.cs new file mode 100644 index 00000000..e721b11b --- /dev/null +++ b/src/WattleScript.Interpreter/Tree/Statements/IBlockStatement.cs @@ -0,0 +1,9 @@ +using WattleScript.Interpreter.Debugging; + +namespace WattleScript.Interpreter.Tree.Statements +{ + interface IBlockStatement + { + SourceRef End { get; } + } +} \ No newline at end of file diff --git a/src/MoonSharp.Interpreter/Tree/Statements/IfStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/IfStatement.cs similarity index 96% rename from src/MoonSharp.Interpreter/Tree/Statements/IfStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/IfStatement.cs index 6deaf813..c97a5188 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/IfStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/IfStatement.cs @@ -1,10 +1,10 @@ using System.Collections.Generic; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class IfStatement : Statement, IBlockStatement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/LabelStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/LabelStatement.cs similarity index 92% rename from src/MoonSharp.Interpreter/Tree/Statements/LabelStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/LabelStatement.cs index 87949e89..daa33d4b 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/LabelStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/LabelStatement.cs @@ -1,8 +1,8 @@ using System.Collections.Generic; -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class LabelStatement : Statement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/RepeatStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/RepeatStatement.cs similarity index 91% rename from src/MoonSharp.Interpreter/Tree/Statements/RepeatStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/RepeatStatement.cs index a9fa75a7..da640627 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/RepeatStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/RepeatStatement.cs @@ -1,9 +1,9 @@ -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class RepeatStatement : Statement, IBlockStatement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/ReturnStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/ReturnStatement.cs similarity index 86% rename from src/MoonSharp.Interpreter/Tree/Statements/ReturnStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/ReturnStatement.cs index b7681752..24f03205 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/ReturnStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/ReturnStatement.cs @@ -1,9 +1,9 @@ -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; -using MoonSharp.Interpreter.Tree.Expressions; +using WattleScript.Interpreter.Tree.Expressions; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class ReturnStatement: Statement { diff --git a/src/MoonSharp.Interpreter/Tree/Statements/WhileStatement.cs b/src/WattleScript.Interpreter/Tree/Statements/WhileStatement.cs similarity index 92% rename from src/MoonSharp.Interpreter/Tree/Statements/WhileStatement.cs rename to src/WattleScript.Interpreter/Tree/Statements/WhileStatement.cs index 632c4a1a..a9a8d49b 100644 --- a/src/MoonSharp.Interpreter/Tree/Statements/WhileStatement.cs +++ b/src/WattleScript.Interpreter/Tree/Statements/WhileStatement.cs @@ -1,9 +1,9 @@ -using MoonSharp.Interpreter.Debugging; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Execution.VM; +using WattleScript.Interpreter.Debugging; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Execution.VM; -namespace MoonSharp.Interpreter.Tree.Statements +namespace WattleScript.Interpreter.Tree.Statements { class WhileStatement : Statement, IBlockStatement { diff --git a/src/MoonSharp.Interpreter/MoonSharp.Interpreter.csproj b/src/WattleScript.Interpreter/WattleScript.Interpreter.csproj similarity index 100% rename from src/MoonSharp.Interpreter/MoonSharp.Interpreter.csproj rename to src/WattleScript.Interpreter/WattleScript.Interpreter.csproj diff --git a/src/MoonSharp.Tests/EndToEnd/AsyncTests.cs b/src/WattleScript.Tests/EndToEnd/AsyncTests.cs similarity index 98% rename from src/MoonSharp.Tests/EndToEnd/AsyncTests.cs rename to src/WattleScript.Tests/EndToEnd/AsyncTests.cs index 073f6c05..3eeb8837 100644 --- a/src/MoonSharp.Tests/EndToEnd/AsyncTests.cs +++ b/src/WattleScript.Tests/EndToEnd/AsyncTests.cs @@ -2,7 +2,7 @@ using System.Threading.Tasks; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class AsyncTests diff --git a/src/MoonSharp.Tests/EndToEnd/BinaryDumpTests.cs b/src/WattleScript.Tests/EndToEnd/BinaryDumpTests.cs similarity index 98% rename from src/MoonSharp.Tests/EndToEnd/BinaryDumpTests.cs rename to src/WattleScript.Tests/EndToEnd/BinaryDumpTests.cs index bf81d5d7..6f42f544 100644 --- a/src/MoonSharp.Tests/EndToEnd/BinaryDumpTests.cs +++ b/src/WattleScript.Tests/EndToEnd/BinaryDumpTests.cs @@ -3,10 +3,10 @@ using System.IO; using System.Linq; using System.Text; -using MoonSharp.Interpreter.IO; +using WattleScript.Interpreter.IO; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class BinaryDumpTests diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/1-null.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/1-null.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/1-null.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/1-null.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/1-null.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/1-null.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/1-null.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/1-null.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/2-this.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/2-this.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/2-this.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/2-this.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/2-this.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/2-this.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/2-this.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Aliases/2-this.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/1-annotation.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/2-annotation.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/3-annotation.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/4-annotation.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Annotations/5-annotation.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Errors/1-common-invalid.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Errors/2-resync-invalid.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/1-call.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/1-call.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/1-call.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/1-call.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/1-call.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/1-call.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/1-call.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/1-call.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/10-call-default-scope-local-3.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/10-call-default-scope-local-3.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/10-call-default-scope-local-3.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/10-call-default-scope-local-3.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/10-call-default-scope-local-3.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/10-call-default-scope-local-3.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/10-call-default-scope-local-3.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/10-call-default-scope-local-3.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/11-call-default-scope-arrow.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/11-call-default-scope-arrow.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/11-call-default-scope-arrow.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/11-call-default-scope-arrow.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/11-call-default-scope-arrow.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/11-call-default-scope-arrow.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/11-call-default-scope-arrow.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/11-call-default-scope-arrow.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/12-call-default-scope-arrow-invalid.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/12-call-default-scope-arrow-invalid.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/12-call-default-scope-arrow-invalid.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/12-call-default-scope-arrow-invalid.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/12-call-default-scope-arrow-invalid.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/12-call-default-scope-arrow-invalid.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/12-call-default-scope-arrow-invalid.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/12-call-default-scope-arrow-invalid.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/13-call-default-scope-arrow-arrow.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/13-call-default-scope-arrow-arrow.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/13-call-default-scope-arrow-arrow.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/13-call-default-scope-arrow-arrow.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/13-call-default-scope-arrow-arrow.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/13-call-default-scope-arrow-arrow.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/13-call-default-scope-arrow-arrow.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/13-call-default-scope-arrow-arrow.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/14-call-default-scope-arrow-arrow-default.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/14-call-default-scope-arrow-arrow-default.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/14-call-default-scope-arrow-arrow-default.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/14-call-default-scope-arrow-arrow-default.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/14-call-default-scope-arrow-arrow-default.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/14-call-default-scope-arrow-arrow-default.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/14-call-default-scope-arrow-arrow-default.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/14-call-default-scope-arrow-arrow-default.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/15-call-default-scope-arrow-arrow-default-2.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/15-call-default-scope-arrow-arrow-default-2.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/15-call-default-scope-arrow-arrow-default-2.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/15-call-default-scope-arrow-arrow-default-2.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/15-call-default-scope-arrow-arrow-default-2.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/15-call-default-scope-arrow-arrow-default-2.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/15-call-default-scope-arrow-arrow-default-2.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/15-call-default-scope-arrow-arrow-default-2.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/16-default-call-closure.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/16-default-call-closure.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/16-default-call-closure.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/16-default-call-closure.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/16-default-call-closure.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/16-default-call-closure.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/16-default-call-closure.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/16-default-call-closure.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/17-call-hoisted.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/17-call-hoisted.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/17-call-hoisted.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/17-call-hoisted.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/17-call-hoisted.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/17-call-hoisted.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/17-call-hoisted.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/17-call-hoisted.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/2-call-default.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/2-call-default.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/2-call-default.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/2-call-default.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/2-call-default.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/2-call-default.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/2-call-default.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/2-call-default.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/3-call-default-invalid.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/3-call-default-invalid.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/3-call-default-invalid.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/3-call-default-invalid.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/3-call-default-invalid.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/3-call-default-invalid.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/3-call-default-invalid.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/3-call-default-invalid.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/4-call-default-2.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/4-call-default-2.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/4-call-default-2.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/4-call-default-2.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/4-call-default-2.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/4-call-default-2.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/4-call-default-2.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/4-call-default-2.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/5-call-default-3.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/5-call-default-3.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/5-call-default-3.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/5-call-default-3.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/5-call-default-3.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/5-call-default-3.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/5-call-default-3.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/5-call-default-3.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/6-call-default-local.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/6-call-default-local.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/6-call-default-local.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/6-call-default-local.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/6-call-default-local.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/6-call-default-local.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/6-call-default-local.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/6-call-default-local.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/7-call-default-scope.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/7-call-default-scope.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/7-call-default-scope.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/7-call-default-scope.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/7-call-default-scope.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/7-call-default-scope.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/7-call-default-scope.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/7-call-default-scope.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/8-call-default-scope-local.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/8-call-default-scope-local.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/8-call-default-scope-local.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/8-call-default-scope-local.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/8-call-default-scope-local.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/8-call-default-scope-local.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/8-call-default-scope-local.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/8-call-default-scope-local.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/9-call-default-scope-local-2.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/9-call-default-scope-local-2.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/9-call-default-scope-local-2.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/9-call-default-scope-local-2.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/9-call-default-scope-local-2.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/9-call-default-scope-local-2.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Functions/9-call-default-scope-local-2.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Functions/9-call-default-scope-local-2.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/0-null-coalescing-assignment-min.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/0-null-coalescing-assignment-min.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/0-null-coalescing-assignment-min.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/0-null-coalescing-assignment-min.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/0-null-coalescing-assignment-min.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/0-null-coalescing-assignment-min.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/0-null-coalescing-assignment-min.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/0-null-coalescing-assignment-min.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/1-null-coalescing-assignment-check.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/1-null-coalescing-assignment-check.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/1-null-coalescing-assignment-check.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/1-null-coalescing-assignment-check.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/1-null-coalescing-assignment-check.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/1-null-coalescing-assignment-check.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/1-null-coalescing-assignment-check.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/1-null-coalescing-assignment-check.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/10-relax-ternary-chain-2.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/10-relax-ternary-chain-2.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/10-relax-ternary-chain-2.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/10-relax-ternary-chain-2.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/10-relax-ternary-chain-2.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/10-relax-ternary-chain-2.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/10-relax-ternary-chain-2.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/10-relax-ternary-chain-2.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/11-nill-coalescing-inverse.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/11-nill-coalescing-inverse.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/11-nill-coalescing-inverse.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/11-nill-coalescing-inverse.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/11-nill-coalescing-inverse.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/11-nill-coalescing-inverse.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/11-nill-coalescing-inverse.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/11-nill-coalescing-inverse.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/12-nill-coalescing-assignment-inverse.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/12-nill-coalescing-assignment-inverse.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/12-nill-coalescing-assignment-inverse.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/12-nill-coalescing-assignment-inverse.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/12-nill-coalescing-assignment-inverse.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/12-nill-coalescing-assignment-inverse.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/12-nill-coalescing-assignment-inverse.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/12-nill-coalescing-assignment-inverse.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/13-nill-coalescing-assignment-inverse-ok.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/13-nill-coalescing-assignment-inverse-ok.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/13-nill-coalescing-assignment-inverse-ok.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/13-nill-coalescing-assignment-inverse-ok.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/13-nill-coalescing-assignment-inverse-ok.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/13-nill-coalescing-assignment-inverse-ok.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/13-nill-coalescing-assignment-inverse-ok.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/13-nill-coalescing-assignment-inverse-ok.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/2-null-coalescing-assignment-scope.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/2-null-coalescing-assignment-scope.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/2-null-coalescing-assignment-scope.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/2-null-coalescing-assignment-scope.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/2-null-coalescing-assignment-scope.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/2-null-coalescing-assignment-scope.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/2-null-coalescing-assignment-scope.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/2-null-coalescing-assignment-scope.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/3-null-coalescing-assignment-local.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/3-null-coalescing-assignment-local.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/3-null-coalescing-assignment-local.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/3-null-coalescing-assignment-local.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/3-null-coalescing-assignment-local.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/3-null-coalescing-assignment-local.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/3-null-coalescing-assignment-local.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/3-null-coalescing-assignment-local.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/4-null-coalescing-assignment-local-scope.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/4-null-coalescing-assignment-local-scope.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/4-null-coalescing-assignment-local-scope.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/4-null-coalescing-assignment-local-scope.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/4-null-coalescing-assignment-local-scope.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/4-null-coalescing-assignment-local-scope.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/4-null-coalescing-assignment-local-scope.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/4-null-coalescing-assignment-local-scope.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/5-null-coalescing-assignment-ternary-skip.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/5-null-coalescing-assignment-ternary-skip.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/5-null-coalescing-assignment-ternary-skip.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/5-null-coalescing-assignment-ternary-skip.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/5-null-coalescing-assignment-ternary-skip.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/5-null-coalescing-assignment-ternary-skip.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/5-null-coalescing-assignment-ternary-skip.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/5-null-coalescing-assignment-ternary-skip.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/6-null-coalescing-assignment-ternary-exec.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/6-null-coalescing-assignment-ternary-exec.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/6-null-coalescing-assignment-ternary-exec.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/6-null-coalescing-assignment-ternary-exec.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/6-null-coalescing-assignment-ternary-exec.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/6-null-coalescing-assignment-ternary-exec.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/6-null-coalescing-assignment-ternary-exec.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/6-null-coalescing-assignment-ternary-exec.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/7-relax-ternary.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/7-relax-ternary.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/7-relax-ternary.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/7-relax-ternary.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/7-relax-ternary.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/7-relax-ternary.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/7-relax-ternary.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/7-relax-ternary.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/8-relax-ternary-cmp.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/8-relax-ternary-cmp.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/8-relax-ternary-cmp.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/8-relax-ternary-cmp.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/8-relax-ternary-cmp.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/8-relax-ternary-cmp.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/8-relax-ternary-cmp.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/8-relax-ternary-cmp.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/9-relax-ternary-chain.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/9-relax-ternary-chain.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/9-relax-ternary-chain.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/9-relax-ternary-chain.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/9-relax-ternary-chain.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/9-relax-ternary-chain.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxCLike/Operators/9-relax-ternary-chain.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxCLike/Operators/9-relax-ternary-chain.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/0-set.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/0-set.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/0-set.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/0-set.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/0-set.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/0-set.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/0-set.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/0-set.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/01-set-double.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/01-set-double.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/01-set-double.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/01-set-double.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/01-set-double.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/01-set-double.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/01-set-double.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/01-set-double.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/1-iterate.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/1-iterate.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/1-iterate.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/1-iterate.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/1-iterate.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/1-iterate.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/1-iterate.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/1-iterate.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/10-concat-from-to.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/10-concat-from-to.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/10-concat-from-to.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/10-concat-from-to.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/10-concat-from-to.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/10-concat-from-to.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/10-concat-from-to.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/10-concat-from-to.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/2-insert.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/2-insert.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/2-insert.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/2-insert.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/2-insert.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/2-insert.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/2-insert.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/2-insert.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/3-sort-simple.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/3-sort-simple.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/3-sort-simple.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/3-sort-simple.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/3-sort-simple.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/3-sort-simple.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/3-sort-simple.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/3-sort-simple.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/4-remove.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/4-remove.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/4-remove.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/4-remove.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/4-remove.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/4-remove.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/4-remove.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/4-remove.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/5-remove-index.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/5-remove-index.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/5-remove-index.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/5-remove-index.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/5-remove-index.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/5-remove-index.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/5-remove-index.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/5-remove-index.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/6-remove-index-multiple.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/6-remove-index-multiple.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/6-remove-index-multiple.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/6-remove-index-multiple.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/6-remove-index-multiple.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/6-remove-index-multiple.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/6-remove-index-multiple.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/6-remove-index-multiple.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/7-concat.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/7-concat.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/7-concat.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/7-concat.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/7-concat.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/7-concat.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/7-concat.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/7-concat.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/8-concat-from.lua b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/8-concat-from.lua similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/8-concat-from.lua rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/8-concat-from.lua diff --git a/src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/8-concat-from.txt b/src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/8-concat-from.txt similarity index 100% rename from src/MoonSharp.Tests/EndToEnd/CLike/SyntaxLua/Tables/8-concat-from.txt rename to src/WattleScript.Tests/EndToEnd/CLike/SyntaxLua/Tables/8-concat-from.txt diff --git a/src/MoonSharp.Tests/EndToEnd/CLikeTestRunner.cs b/src/WattleScript.Tests/EndToEnd/CLikeTestRunner.cs similarity index 98% rename from src/MoonSharp.Tests/EndToEnd/CLikeTestRunner.cs rename to src/WattleScript.Tests/EndToEnd/CLikeTestRunner.cs index 801f7cfb..4edb58b5 100644 --- a/src/MoonSharp.Tests/EndToEnd/CLikeTestRunner.cs +++ b/src/WattleScript.Tests/EndToEnd/CLikeTestRunner.cs @@ -5,7 +5,7 @@ using System.Threading.Tasks; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests; +namespace WattleScript.Interpreter.Tests; public class CLikeTestRunner { diff --git a/src/MoonSharp.Tests/EndToEnd/CSyntaxTests.cs b/src/WattleScript.Tests/EndToEnd/CSyntaxTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/CSyntaxTests.cs rename to src/WattleScript.Tests/EndToEnd/CSyntaxTests.cs index b8c1bdd1..fd2c222d 100644 --- a/src/MoonSharp.Tests/EndToEnd/CSyntaxTests.cs +++ b/src/WattleScript.Tests/EndToEnd/CSyntaxTests.cs @@ -3,7 +3,7 @@ using System.Threading.Tasks; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class CSyntaxTests diff --git a/src/MoonSharp.Tests/EndToEnd/ClosureTests.cs b/src/WattleScript.Tests/EndToEnd/ClosureTests.cs similarity index 98% rename from src/MoonSharp.Tests/EndToEnd/ClosureTests.cs rename to src/WattleScript.Tests/EndToEnd/ClosureTests.cs index f81d7efd..90d6a7c3 100644 --- a/src/MoonSharp.Tests/EndToEnd/ClosureTests.cs +++ b/src/WattleScript.Tests/EndToEnd/ClosureTests.cs @@ -1,8 +1,8 @@ using System; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Execution; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class ClosureTests diff --git a/src/MoonSharp.Tests/EndToEnd/CollectionsBaseGenRegisteredTests.cs b/src/WattleScript.Tests/EndToEnd/CollectionsBaseGenRegisteredTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/CollectionsBaseGenRegisteredTests.cs rename to src/WattleScript.Tests/EndToEnd/CollectionsBaseGenRegisteredTests.cs index dbb7776c..a0132484 100755 --- a/src/MoonSharp.Tests/EndToEnd/CollectionsBaseGenRegisteredTests.cs +++ b/src/WattleScript.Tests/EndToEnd/CollectionsBaseGenRegisteredTests.cs @@ -6,7 +6,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class CollectionsBaseGenRegisteredTests diff --git a/src/MoonSharp.Tests/EndToEnd/CollectionsBaseInterfGenRegisteredTests.cs b/src/WattleScript.Tests/EndToEnd/CollectionsBaseInterfGenRegisteredTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/CollectionsBaseInterfGenRegisteredTests.cs rename to src/WattleScript.Tests/EndToEnd/CollectionsBaseInterfGenRegisteredTests.cs index 1281d9fb..40e2824c 100644 --- a/src/MoonSharp.Tests/EndToEnd/CollectionsBaseInterfGenRegisteredTests.cs +++ b/src/WattleScript.Tests/EndToEnd/CollectionsBaseInterfGenRegisteredTests.cs @@ -6,7 +6,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { public class RegCollItem { diff --git a/src/MoonSharp.Tests/EndToEnd/CollectionsRegisteredTests.cs b/src/WattleScript.Tests/EndToEnd/CollectionsRegisteredTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/CollectionsRegisteredTests.cs rename to src/WattleScript.Tests/EndToEnd/CollectionsRegisteredTests.cs index 462d32fc..e454c1d6 100644 --- a/src/MoonSharp.Tests/EndToEnd/CollectionsRegisteredTests.cs +++ b/src/WattleScript.Tests/EndToEnd/CollectionsRegisteredTests.cs @@ -5,7 +5,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class CollectionsRegisteredTests diff --git a/src/MoonSharp.Tests/EndToEnd/ConfigPropertyAssignerTests.cs b/src/WattleScript.Tests/EndToEnd/ConfigPropertyAssignerTests.cs similarity index 87% rename from src/MoonSharp.Tests/EndToEnd/ConfigPropertyAssignerTests.cs rename to src/WattleScript.Tests/EndToEnd/ConfigPropertyAssignerTests.cs index d6cf5925..82942a6a 100644 --- a/src/MoonSharp.Tests/EndToEnd/ConfigPropertyAssignerTests.cs +++ b/src/WattleScript.Tests/EndToEnd/ConfigPropertyAssignerTests.cs @@ -2,38 +2,38 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.Interop; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class ConfigPropertyAssignerTests { private class MySubclass { - [MoonSharpProperty] + [WattleScriptProperty] public string MyString { get; set; } - [MoonSharpProperty("number")] + [WattleScriptProperty("number")] public int MyNumber { get; private set; } } private class MyClass { - [MoonSharpProperty] + [WattleScriptProperty] public string MyString { get; set; } - [MoonSharpProperty("number")] + [WattleScriptProperty("number")] public int MyNumber { get; private set; } - [MoonSharpProperty] + [WattleScriptProperty] internal Table SomeTable { get; private set; } - [MoonSharpProperty] + [WattleScriptProperty] public DynValue NativeValue { get; private set; } - [MoonSharpProperty] + [WattleScriptProperty] public MySubclass SubObj { get; private set; } } diff --git a/src/MoonSharp.Tests/EndToEnd/CoroutineTests.cs b/src/WattleScript.Tests/EndToEnd/CoroutineTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/CoroutineTests.cs rename to src/WattleScript.Tests/EndToEnd/CoroutineTests.cs index 86d70daf..fadb70e4 100644 --- a/src/MoonSharp.Tests/EndToEnd/CoroutineTests.cs +++ b/src/WattleScript.Tests/EndToEnd/CoroutineTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] class CoroutineTests diff --git a/src/MoonSharp.Tests/EndToEnd/DynamicTests.cs b/src/WattleScript.Tests/EndToEnd/DynamicTests.cs similarity index 92% rename from src/MoonSharp.Tests/EndToEnd/DynamicTests.cs rename to src/WattleScript.Tests/EndToEnd/DynamicTests.cs index bde078c6..8d7c3440 100644 --- a/src/MoonSharp.Tests/EndToEnd/DynamicTests.cs +++ b/src/WattleScript.Tests/EndToEnd/DynamicTests.cs @@ -2,11 +2,11 @@ using System.Text; using System.Collections.Generic; using System.Linq; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Execution; using NUnit.Framework; -using MoonSharp.Interpreter.CoreLib; +using WattleScript.Interpreter.CoreLib; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class DynamicTests diff --git a/src/MoonSharp.Tests/EndToEnd/ErrorHandlingTests.cs b/src/WattleScript.Tests/EndToEnd/ErrorHandlingTests.cs similarity index 97% rename from src/MoonSharp.Tests/EndToEnd/ErrorHandlingTests.cs rename to src/WattleScript.Tests/EndToEnd/ErrorHandlingTests.cs index 24d76266..77ce6465 100644 --- a/src/MoonSharp.Tests/EndToEnd/ErrorHandlingTests.cs +++ b/src/WattleScript.Tests/EndToEnd/ErrorHandlingTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class ErrorHandlingTests diff --git a/src/MoonSharp.Tests/EndToEnd/FunctionTests.cs b/src/WattleScript.Tests/EndToEnd/FunctionTests.cs similarity index 95% rename from src/MoonSharp.Tests/EndToEnd/FunctionTests.cs rename to src/WattleScript.Tests/EndToEnd/FunctionTests.cs index a7a8bdbd..97df59fc 100644 --- a/src/MoonSharp.Tests/EndToEnd/FunctionTests.cs +++ b/src/WattleScript.Tests/EndToEnd/FunctionTests.cs @@ -2,7 +2,7 @@ using System.Threading.Tasks; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class FunctionTests diff --git a/src/MoonSharp.Tests/EndToEnd/GotoTests.cs b/src/WattleScript.Tests/EndToEnd/GotoTests.cs similarity index 98% rename from src/MoonSharp.Tests/EndToEnd/GotoTests.cs rename to src/WattleScript.Tests/EndToEnd/GotoTests.cs index 719cc076..f5d6e7c9 100644 --- a/src/MoonSharp.Tests/EndToEnd/GotoTests.cs +++ b/src/WattleScript.Tests/EndToEnd/GotoTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class GotoTests diff --git a/src/MoonSharp.Tests/EndToEnd/JsonSerializationTests.cs b/src/WattleScript.Tests/EndToEnd/JsonSerializationTests.cs similarity index 96% rename from src/MoonSharp.Tests/EndToEnd/JsonSerializationTests.cs rename to src/WattleScript.Tests/EndToEnd/JsonSerializationTests.cs index e1fae5cd..368c3593 100755 --- a/src/MoonSharp.Tests/EndToEnd/JsonSerializationTests.cs +++ b/src/WattleScript.Tests/EndToEnd/JsonSerializationTests.cs @@ -2,12 +2,12 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Serialization.Json; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Serialization.Json; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class JsonSerializationTests diff --git a/src/MoonSharp.Tests/EndToEnd/LuaTestSuiteExtract.cs b/src/WattleScript.Tests/EndToEnd/LuaTestSuiteExtract.cs similarity index 96% rename from src/MoonSharp.Tests/EndToEnd/LuaTestSuiteExtract.cs rename to src/WattleScript.Tests/EndToEnd/LuaTestSuiteExtract.cs index 47f4293b..d9799efb 100644 --- a/src/MoonSharp.Tests/EndToEnd/LuaTestSuiteExtract.cs +++ b/src/WattleScript.Tests/EndToEnd/LuaTestSuiteExtract.cs @@ -1,12 +1,12 @@ using System; using System.Collections.Generic; -using MoonSharp.Interpreter.Diagnostics; +using WattleScript.Interpreter.Diagnostics; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Execution; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { /// /// Selected tests extracted from Lua test suite diff --git a/src/MoonSharp.Tests/EndToEnd/MetatableTests.cs b/src/WattleScript.Tests/EndToEnd/MetatableTests.cs similarity index 97% rename from src/MoonSharp.Tests/EndToEnd/MetatableTests.cs rename to src/WattleScript.Tests/EndToEnd/MetatableTests.cs index f8d25ff7..5b2eb0fc 100644 --- a/src/MoonSharp.Tests/EndToEnd/MetatableTests.cs +++ b/src/WattleScript.Tests/EndToEnd/MetatableTests.cs @@ -2,11 +2,11 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.CoreLib; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.CoreLib; +using WattleScript.Interpreter.Execution; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class MetatableTests diff --git a/src/MoonSharp.Tests/EndToEnd/ProxyObjectsTests.cs b/src/WattleScript.Tests/EndToEnd/ProxyObjectsTests.cs similarity index 82% rename from src/MoonSharp.Tests/EndToEnd/ProxyObjectsTests.cs rename to src/WattleScript.Tests/EndToEnd/ProxyObjectsTests.cs index 9c85a990..531af30c 100644 --- a/src/MoonSharp.Tests/EndToEnd/ProxyObjectsTests.cs +++ b/src/WattleScript.Tests/EndToEnd/ProxyObjectsTests.cs @@ -2,20 +2,20 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.Interop; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class ProxyObjectsTests { public class Proxy { - [MoonSharpVisible(false)] + [WattleScriptVisible(false)] public Random random; - [MoonSharpVisible(false)] + [WattleScriptVisible(false)] public Proxy(Random r) { random = r; diff --git a/src/MoonSharp.Tests/EndToEnd/SimpleTests.cs b/src/WattleScript.Tests/EndToEnd/SimpleTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/SimpleTests.cs rename to src/WattleScript.Tests/EndToEnd/SimpleTests.cs index b4ba324d..d9060c70 100644 --- a/src/MoonSharp.Tests/EndToEnd/SimpleTests.cs +++ b/src/WattleScript.Tests/EndToEnd/SimpleTests.cs @@ -1,11 +1,11 @@ using System; using System.Linq; using System.Collections.Generic; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Execution; using NUnit.Framework; -using MoonSharp.Interpreter.Loaders; +using WattleScript.Interpreter.Loaders; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class SimpleTests diff --git a/src/MoonSharp.Tests/EndToEnd/StringLibTests.cs b/src/WattleScript.Tests/EndToEnd/StringLibTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/StringLibTests.cs rename to src/WattleScript.Tests/EndToEnd/StringLibTests.cs index ab859bcb..6383ba09 100644 --- a/src/MoonSharp.Tests/EndToEnd/StringLibTests.cs +++ b/src/WattleScript.Tests/EndToEnd/StringLibTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class StringLibTests diff --git a/src/MoonSharp.Tests/EndToEnd/StructAssignmentTechnique.cs b/src/WattleScript.Tests/EndToEnd/StructAssignmentTechnique.cs similarity index 94% rename from src/MoonSharp.Tests/EndToEnd/StructAssignmentTechnique.cs rename to src/WattleScript.Tests/EndToEnd/StructAssignmentTechnique.cs index 421ea770..4eeb8ee7 100755 --- a/src/MoonSharp.Tests/EndToEnd/StructAssignmentTechnique.cs +++ b/src/WattleScript.Tests/EndToEnd/StructAssignmentTechnique.cs @@ -2,10 +2,10 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Interop.BasicDescriptors; +using WattleScript.Interpreter.Interop.BasicDescriptors; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class StructAssignmentTechnique diff --git a/src/MoonSharp.Tests/EndToEnd/TableTests.cs b/src/WattleScript.Tests/EndToEnd/TableTests.cs similarity index 98% rename from src/MoonSharp.Tests/EndToEnd/TableTests.cs rename to src/WattleScript.Tests/EndToEnd/TableTests.cs index aa9e14b9..4991bfa1 100644 --- a/src/MoonSharp.Tests/EndToEnd/TableTests.cs +++ b/src/WattleScript.Tests/EndToEnd/TableTests.cs @@ -2,11 +2,11 @@ using System.Text; using System.Collections.Generic; using System.Linq; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Execution; using NUnit.Framework; -using MoonSharp.Interpreter.CoreLib; +using WattleScript.Interpreter.CoreLib; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class TableTests diff --git a/src/MoonSharp.Tests/EndToEnd/TailCallTests.cs b/src/WattleScript.Tests/EndToEnd/TailCallTests.cs similarity index 96% rename from src/MoonSharp.Tests/EndToEnd/TailCallTests.cs rename to src/WattleScript.Tests/EndToEnd/TailCallTests.cs index d21553a3..732ff1b9 100644 --- a/src/MoonSharp.Tests/EndToEnd/TailCallTests.cs +++ b/src/WattleScript.Tests/EndToEnd/TailCallTests.cs @@ -2,10 +2,10 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Execution; +using WattleScript.Interpreter.Execution; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class TailCallTests diff --git a/src/MoonSharp.Tests/EndToEnd/UserDataEnumsTest.cs b/src/WattleScript.Tests/EndToEnd/UserDataEnumsTest.cs similarity index 98% rename from src/MoonSharp.Tests/EndToEnd/UserDataEnumsTest.cs rename to src/WattleScript.Tests/EndToEnd/UserDataEnumsTest.cs index 68f2b9ae..55fe8e34 100644 --- a/src/MoonSharp.Tests/EndToEnd/UserDataEnumsTest.cs +++ b/src/WattleScript.Tests/EndToEnd/UserDataEnumsTest.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { public enum MyEnum : short { diff --git a/src/MoonSharp.Tests/EndToEnd/UserDataEventsTests.cs b/src/WattleScript.Tests/EndToEnd/UserDataEventsTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/UserDataEventsTests.cs rename to src/WattleScript.Tests/EndToEnd/UserDataEventsTests.cs index 45de47b7..3ea72928 100644 --- a/src/MoonSharp.Tests/EndToEnd/UserDataEventsTests.cs +++ b/src/WattleScript.Tests/EndToEnd/UserDataEventsTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { #pragma warning disable 169 // unused private field diff --git a/src/MoonSharp.Tests/EndToEnd/UserDataFieldsTests.cs b/src/WattleScript.Tests/EndToEnd/UserDataFieldsTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/UserDataFieldsTests.cs rename to src/WattleScript.Tests/EndToEnd/UserDataFieldsTests.cs index 0474ec0a..cd9b84ee 100644 --- a/src/MoonSharp.Tests/EndToEnd/UserDataFieldsTests.cs +++ b/src/WattleScript.Tests/EndToEnd/UserDataFieldsTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { #pragma warning disable 169 // unused private field diff --git a/src/MoonSharp.Tests/EndToEnd/UserDataIndexerTests.cs b/src/WattleScript.Tests/EndToEnd/UserDataIndexerTests.cs similarity index 98% rename from src/MoonSharp.Tests/EndToEnd/UserDataIndexerTests.cs rename to src/WattleScript.Tests/EndToEnd/UserDataIndexerTests.cs index a32054ba..85db0d9d 100644 --- a/src/MoonSharp.Tests/EndToEnd/UserDataIndexerTests.cs +++ b/src/WattleScript.Tests/EndToEnd/UserDataIndexerTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class UserDataIndexerTests diff --git a/src/MoonSharp.Tests/EndToEnd/UserDataMetaTests.cs b/src/WattleScript.Tests/EndToEnd/UserDataMetaTests.cs similarity index 95% rename from src/MoonSharp.Tests/EndToEnd/UserDataMetaTests.cs rename to src/WattleScript.Tests/EndToEnd/UserDataMetaTests.cs index dd50dba7..4ff596ff 100644 --- a/src/MoonSharp.Tests/EndToEnd/UserDataMetaTests.cs +++ b/src/WattleScript.Tests/EndToEnd/UserDataMetaTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class UserDataMetaTests @@ -38,22 +38,22 @@ public ArithmOperatorsTestClass(int value) return new ArithmOperatorsTestClass(-o.Value); } - [MoonSharpUserDataMetamethod("__concat")] - [MoonSharpUserDataMetamethod("__pow")] + [WattleScriptUserDataMetamethod("__concat")] + [WattleScriptUserDataMetamethod("__pow")] public static int operator +(ArithmOperatorsTestClass o, int v) { return o.Value + v; } - [MoonSharpUserDataMetamethod("__concat")] - [MoonSharpUserDataMetamethod("__pow")] + [WattleScriptUserDataMetamethod("__concat")] + [WattleScriptUserDataMetamethod("__pow")] public static int operator +(int v, ArithmOperatorsTestClass o) { return o.Value + v; } - [MoonSharpUserDataMetamethod("__concat")] - [MoonSharpUserDataMetamethod("__pow")] + [WattleScriptUserDataMetamethod("__concat")] + [WattleScriptUserDataMetamethod("__pow")] public static int operator +(ArithmOperatorsTestClass o1, ArithmOperatorsTestClass o2) { return o1.Value + o2.Value; @@ -150,14 +150,14 @@ public System.Collections.IEnumerator GetEnumerator() return (new List() { 1, 2, 3 }).GetEnumerator(); } - [MoonSharpUserDataMetamethod("__call")] + [WattleScriptUserDataMetamethod("__call")] public int DefaultMethod() { return -Value; } - [MoonSharpUserDataMetamethod("__pairs")] - [MoonSharpUserDataMetamethod("__ipairs")] + [WattleScriptUserDataMetamethod("__pairs")] + [WattleScriptUserDataMetamethod("__ipairs")] public System.Collections.IEnumerator Pairs() { return (new List() { diff --git a/src/MoonSharp.Tests/EndToEnd/UserDataMethodsTests.cs b/src/WattleScript.Tests/EndToEnd/UserDataMethodsTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/UserDataMethodsTests.cs rename to src/WattleScript.Tests/EndToEnd/UserDataMethodsTests.cs index 9f8657da..a01d8d38 100755 --- a/src/MoonSharp.Tests/EndToEnd/UserDataMethodsTests.cs +++ b/src/WattleScript.Tests/EndToEnd/UserDataMethodsTests.cs @@ -2,10 +2,10 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.Interop; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class UserDataMethodsTests diff --git a/src/MoonSharp.Tests/EndToEnd/UserDataNestedTypesTests.cs b/src/WattleScript.Tests/EndToEnd/UserDataNestedTypesTests.cs similarity index 97% rename from src/MoonSharp.Tests/EndToEnd/UserDataNestedTypesTests.cs rename to src/WattleScript.Tests/EndToEnd/UserDataNestedTypesTests.cs index 0f1317f0..9372ecfc 100644 --- a/src/MoonSharp.Tests/EndToEnd/UserDataNestedTypesTests.cs +++ b/src/WattleScript.Tests/EndToEnd/UserDataNestedTypesTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class UserDataNestedTypesTests @@ -29,7 +29,7 @@ public static string Get() } } - [MoonSharpUserData] + [WattleScriptUserData] private class SomeNestedTypePrivate { public static string Get() @@ -58,7 +58,7 @@ public static string Get() } } - [MoonSharpUserData] + [WattleScriptUserData] private struct SomeNestedTypePrivate { public static string Get() diff --git a/src/MoonSharp.Tests/EndToEnd/UserDataOverloadsTests.cs b/src/WattleScript.Tests/EndToEnd/UserDataOverloadsTests.cs similarity index 98% rename from src/MoonSharp.Tests/EndToEnd/UserDataOverloadsTests.cs rename to src/WattleScript.Tests/EndToEnd/UserDataOverloadsTests.cs index 2e7a3b18..63ef2985 100755 --- a/src/MoonSharp.Tests/EndToEnd/UserDataOverloadsTests.cs +++ b/src/WattleScript.Tests/EndToEnd/UserDataOverloadsTests.cs @@ -4,11 +4,11 @@ using System.Linq; using System.Reflection; using System.Text; -using MoonSharp.Interpreter.Interop; -using MoonSharp.Interpreter.Loaders; +using WattleScript.Interpreter.Interop; +using WattleScript.Interpreter.Loaders; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { public static class OverloadsExtMethods { diff --git a/src/MoonSharp.Tests/EndToEnd/UserDataPropertiesTests.cs b/src/WattleScript.Tests/EndToEnd/UserDataPropertiesTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/UserDataPropertiesTests.cs rename to src/WattleScript.Tests/EndToEnd/UserDataPropertiesTests.cs index f51565bd..7fee2525 100644 --- a/src/MoonSharp.Tests/EndToEnd/UserDataPropertiesTests.cs +++ b/src/WattleScript.Tests/EndToEnd/UserDataPropertiesTests.cs @@ -2,10 +2,10 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.Interop; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class UserDataPropertiesTests @@ -23,11 +23,11 @@ public class SomeClass public int WoIntProp { set { IntProp = value; } } public int WoIntProp2 { internal get; set; } - [MoonSharpVisible(false)] + [WattleScriptVisible(false)] internal int AccessOverrProp { get; - [MoonSharpVisible(true)] + [WattleScriptVisible(true)] set; } diff --git a/src/MoonSharp.Tests/EndToEnd/Utils.cs b/src/WattleScript.Tests/EndToEnd/Utils.cs similarity index 96% rename from src/MoonSharp.Tests/EndToEnd/Utils.cs rename to src/WattleScript.Tests/EndToEnd/Utils.cs index e9024a41..eff1064f 100644 --- a/src/MoonSharp.Tests/EndToEnd/Utils.cs +++ b/src/WattleScript.Tests/EndToEnd/Utils.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { public static class Utils { diff --git a/src/MoonSharp.Tests/EndToEnd/VarargsTupleTests.cs b/src/WattleScript.Tests/EndToEnd/VarargsTupleTests.cs similarity index 97% rename from src/MoonSharp.Tests/EndToEnd/VarargsTupleTests.cs rename to src/WattleScript.Tests/EndToEnd/VarargsTupleTests.cs index 503b2f8d..a9536f8f 100644 --- a/src/MoonSharp.Tests/EndToEnd/VarargsTupleTests.cs +++ b/src/WattleScript.Tests/EndToEnd/VarargsTupleTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class VarargsTupleTests diff --git a/src/MoonSharp.Tests/EndToEnd/VtUserDataFieldsTests.cs b/src/WattleScript.Tests/EndToEnd/VtUserDataFieldsTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/VtUserDataFieldsTests.cs rename to src/WattleScript.Tests/EndToEnd/VtUserDataFieldsTests.cs index a5cbdc60..1ca0f66a 100644 --- a/src/MoonSharp.Tests/EndToEnd/VtUserDataFieldsTests.cs +++ b/src/WattleScript.Tests/EndToEnd/VtUserDataFieldsTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { #pragma warning disable 169 // unused private field diff --git a/src/MoonSharp.Tests/EndToEnd/VtUserDataIndexerTests.cs b/src/WattleScript.Tests/EndToEnd/VtUserDataIndexerTests.cs similarity index 98% rename from src/MoonSharp.Tests/EndToEnd/VtUserDataIndexerTests.cs rename to src/WattleScript.Tests/EndToEnd/VtUserDataIndexerTests.cs index 033b32b6..3b187738 100644 --- a/src/MoonSharp.Tests/EndToEnd/VtUserDataIndexerTests.cs +++ b/src/WattleScript.Tests/EndToEnd/VtUserDataIndexerTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class VtUserDataIndexerTests diff --git a/src/MoonSharp.Tests/EndToEnd/VtUserDataMetaTests.cs b/src/WattleScript.Tests/EndToEnd/VtUserDataMetaTests.cs similarity index 95% rename from src/MoonSharp.Tests/EndToEnd/VtUserDataMetaTests.cs rename to src/WattleScript.Tests/EndToEnd/VtUserDataMetaTests.cs index 22f098ce..d0c0e005 100644 --- a/src/MoonSharp.Tests/EndToEnd/VtUserDataMetaTests.cs +++ b/src/WattleScript.Tests/EndToEnd/VtUserDataMetaTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class VtUserDataMetaTests @@ -36,22 +36,22 @@ public ArithmOperatorsTestClass(int value) return new ArithmOperatorsTestClass(-o.Value); } - [MoonSharpUserDataMetamethod("__concat")] - [MoonSharpUserDataMetamethod("__pow")] + [WattleScriptUserDataMetamethod("__concat")] + [WattleScriptUserDataMetamethod("__pow")] public static int operator +(ArithmOperatorsTestClass o, int v) { return o.Value + v; } - [MoonSharpUserDataMetamethod("__concat")] - [MoonSharpUserDataMetamethod("__pow")] + [WattleScriptUserDataMetamethod("__concat")] + [WattleScriptUserDataMetamethod("__pow")] public static int operator +(int v, ArithmOperatorsTestClass o) { return o.Value + v; } - [MoonSharpUserDataMetamethod("__concat")] - [MoonSharpUserDataMetamethod("__pow")] + [WattleScriptUserDataMetamethod("__concat")] + [WattleScriptUserDataMetamethod("__pow")] public static int operator +(ArithmOperatorsTestClass o1, ArithmOperatorsTestClass o2) { return o1.Value + o2.Value; @@ -152,14 +152,14 @@ public System.Collections.IEnumerator GetEnumerator() return (new List() { 1, 2, 3 }).GetEnumerator(); } - [MoonSharpUserDataMetamethod("__call")] + [WattleScriptUserDataMetamethod("__call")] public int DefaultMethod() { return -Value; } - [MoonSharpUserDataMetamethod("__pairs")] - [MoonSharpUserDataMetamethod("__ipairs")] + [WattleScriptUserDataMetamethod("__pairs")] + [WattleScriptUserDataMetamethod("__ipairs")] public System.Collections.IEnumerator Pairs() { return (new List() { diff --git a/src/MoonSharp.Tests/EndToEnd/VtUserDataMethodsTests.cs b/src/WattleScript.Tests/EndToEnd/VtUserDataMethodsTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/VtUserDataMethodsTests.cs rename to src/WattleScript.Tests/EndToEnd/VtUserDataMethodsTests.cs index 38231301..1a1f86a4 100755 --- a/src/MoonSharp.Tests/EndToEnd/VtUserDataMethodsTests.cs +++ b/src/WattleScript.Tests/EndToEnd/VtUserDataMethodsTests.cs @@ -2,10 +2,10 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.Interop; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class VtUserDataMethodsTests diff --git a/src/MoonSharp.Tests/EndToEnd/VtUserDataOverloadsTests.cs b/src/WattleScript.Tests/EndToEnd/VtUserDataOverloadsTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/VtUserDataOverloadsTests.cs rename to src/WattleScript.Tests/EndToEnd/VtUserDataOverloadsTests.cs index 161daf32..4f1bc122 100755 --- a/src/MoonSharp.Tests/EndToEnd/VtUserDataOverloadsTests.cs +++ b/src/WattleScript.Tests/EndToEnd/VtUserDataOverloadsTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { public static class VtOverloadsExtMethods { diff --git a/src/MoonSharp.Tests/EndToEnd/VtUserDataPropertiesTests.cs b/src/WattleScript.Tests/EndToEnd/VtUserDataPropertiesTests.cs similarity index 99% rename from src/MoonSharp.Tests/EndToEnd/VtUserDataPropertiesTests.cs rename to src/WattleScript.Tests/EndToEnd/VtUserDataPropertiesTests.cs index 459a15ae..4a1e8885 100644 --- a/src/MoonSharp.Tests/EndToEnd/VtUserDataPropertiesTests.cs +++ b/src/WattleScript.Tests/EndToEnd/VtUserDataPropertiesTests.cs @@ -2,10 +2,10 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter.Interop; +using WattleScript.Interpreter.Interop; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests.EndToEnd +namespace WattleScript.Interpreter.Tests.EndToEnd { [TestFixture] public class VtUserDataPropertiesTests @@ -26,11 +26,11 @@ public struct SomeClass public int GetWoIntProp2() { return WoIntProp2; } - [MoonSharpVisible(false)] + [WattleScriptVisible(false)] internal int AccessOverrProp { get; - [MoonSharpVisible(true)] + [WattleScriptVisible(true)] set; } diff --git a/src/MoonSharp.Tests/TapRunner.cs b/src/WattleScript.Tests/TapRunner.cs similarity index 88% rename from src/MoonSharp.Tests/TapRunner.cs rename to src/WattleScript.Tests/TapRunner.cs index de87126a..7ac91565 100644 --- a/src/MoonSharp.Tests/TapRunner.cs +++ b/src/WattleScript.Tests/TapRunner.cs @@ -5,13 +5,13 @@ using System.Linq; using System.Reflection; using System.Text; -using MoonSharp.Interpreter.CoreLib; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Loaders; -using MoonSharp.Interpreter.Platforms; +using WattleScript.Interpreter.CoreLib; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Loaders; +using WattleScript.Interpreter.Platforms; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests +namespace WattleScript.Interpreter.Tests { #if !EMBEDTEST class TestsScriptLoader : ScriptLoaderBase diff --git a/src/MoonSharp.Tests/TestMore/000-sanity.t b/src/WattleScript.Tests/TestMore/000-sanity.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/000-sanity.t rename to src/WattleScript.Tests/TestMore/000-sanity.t diff --git a/src/MoonSharp.Tests/TestMore/001-if.t b/src/WattleScript.Tests/TestMore/001-if.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/001-if.t rename to src/WattleScript.Tests/TestMore/001-if.t diff --git a/src/MoonSharp.Tests/TestMore/002-table.t b/src/WattleScript.Tests/TestMore/002-table.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/002-table.t rename to src/WattleScript.Tests/TestMore/002-table.t diff --git a/src/MoonSharp.Tests/TestMore/011-while.t b/src/WattleScript.Tests/TestMore/011-while.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/011-while.t rename to src/WattleScript.Tests/TestMore/011-while.t diff --git a/src/MoonSharp.Tests/TestMore/012-repeat.t b/src/WattleScript.Tests/TestMore/012-repeat.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/012-repeat.t rename to src/WattleScript.Tests/TestMore/012-repeat.t diff --git a/src/MoonSharp.Tests/TestMore/014-fornum.t b/src/WattleScript.Tests/TestMore/014-fornum.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/014-fornum.t rename to src/WattleScript.Tests/TestMore/014-fornum.t diff --git a/src/MoonSharp.Tests/TestMore/015-forlist.t b/src/WattleScript.Tests/TestMore/015-forlist.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/015-forlist.t rename to src/WattleScript.Tests/TestMore/015-forlist.t diff --git a/src/MoonSharp.Tests/TestMore/101-boolean.t b/src/WattleScript.Tests/TestMore/101-boolean.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/101-boolean.t rename to src/WattleScript.Tests/TestMore/101-boolean.t diff --git a/src/MoonSharp.Tests/TestMore/102-function.t b/src/WattleScript.Tests/TestMore/102-function.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/102-function.t rename to src/WattleScript.Tests/TestMore/102-function.t diff --git a/src/MoonSharp.Tests/TestMore/103-nil.t b/src/WattleScript.Tests/TestMore/103-nil.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/103-nil.t rename to src/WattleScript.Tests/TestMore/103-nil.t diff --git a/src/MoonSharp.Tests/TestMore/104-number.t b/src/WattleScript.Tests/TestMore/104-number.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/104-number.t rename to src/WattleScript.Tests/TestMore/104-number.t diff --git a/src/MoonSharp.Tests/TestMore/105-string.t b/src/WattleScript.Tests/TestMore/105-string.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/105-string.t rename to src/WattleScript.Tests/TestMore/105-string.t diff --git a/src/MoonSharp.Tests/TestMore/106-table.t b/src/WattleScript.Tests/TestMore/106-table.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/106-table.t rename to src/WattleScript.Tests/TestMore/106-table.t diff --git a/src/MoonSharp.Tests/TestMore/107-thread.t b/src/WattleScript.Tests/TestMore/107-thread.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/107-thread.t rename to src/WattleScript.Tests/TestMore/107-thread.t diff --git a/src/MoonSharp.Tests/TestMore/108-userdata.t b/src/WattleScript.Tests/TestMore/108-userdata.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/108-userdata.t rename to src/WattleScript.Tests/TestMore/108-userdata.t diff --git a/src/MoonSharp.Tests/TestMore/200-examples.t b/src/WattleScript.Tests/TestMore/200-examples.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/200-examples.t rename to src/WattleScript.Tests/TestMore/200-examples.t diff --git a/src/MoonSharp.Tests/TestMore/201-assign.t b/src/WattleScript.Tests/TestMore/201-assign.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/201-assign.t rename to src/WattleScript.Tests/TestMore/201-assign.t diff --git a/src/MoonSharp.Tests/TestMore/202-expr.t b/src/WattleScript.Tests/TestMore/202-expr.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/202-expr.t rename to src/WattleScript.Tests/TestMore/202-expr.t diff --git a/src/MoonSharp.Tests/TestMore/203-lexico.t b/src/WattleScript.Tests/TestMore/203-lexico.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/203-lexico.t rename to src/WattleScript.Tests/TestMore/203-lexico.t diff --git a/src/MoonSharp.Tests/TestMore/204-grammar.t b/src/WattleScript.Tests/TestMore/204-grammar.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/204-grammar.t rename to src/WattleScript.Tests/TestMore/204-grammar.t diff --git a/src/MoonSharp.Tests/TestMore/211-scope.t b/src/WattleScript.Tests/TestMore/211-scope.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/211-scope.t rename to src/WattleScript.Tests/TestMore/211-scope.t diff --git a/src/MoonSharp.Tests/TestMore/212-function.t b/src/WattleScript.Tests/TestMore/212-function.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/212-function.t rename to src/WattleScript.Tests/TestMore/212-function.t diff --git a/src/MoonSharp.Tests/TestMore/213-closure.t b/src/WattleScript.Tests/TestMore/213-closure.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/213-closure.t rename to src/WattleScript.Tests/TestMore/213-closure.t diff --git a/src/MoonSharp.Tests/TestMore/214-coroutine.t b/src/WattleScript.Tests/TestMore/214-coroutine.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/214-coroutine.t rename to src/WattleScript.Tests/TestMore/214-coroutine.t diff --git a/src/MoonSharp.Tests/TestMore/221-table.t b/src/WattleScript.Tests/TestMore/221-table.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/221-table.t rename to src/WattleScript.Tests/TestMore/221-table.t diff --git a/src/MoonSharp.Tests/TestMore/222-constructor.t b/src/WattleScript.Tests/TestMore/222-constructor.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/222-constructor.t rename to src/WattleScript.Tests/TestMore/222-constructor.t diff --git a/src/MoonSharp.Tests/TestMore/223-iterator.t b/src/WattleScript.Tests/TestMore/223-iterator.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/223-iterator.t rename to src/WattleScript.Tests/TestMore/223-iterator.t diff --git a/src/MoonSharp.Tests/TestMore/231-metatable.t b/src/WattleScript.Tests/TestMore/231-metatable.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/231-metatable.t rename to src/WattleScript.Tests/TestMore/231-metatable.t diff --git a/src/MoonSharp.Tests/TestMore/232-object.t b/src/WattleScript.Tests/TestMore/232-object.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/232-object.t rename to src/WattleScript.Tests/TestMore/232-object.t diff --git a/src/MoonSharp.Tests/TestMore/301-basic.t b/src/WattleScript.Tests/TestMore/301-basic.t similarity index 96% rename from src/MoonSharp.Tests/TestMore/301-basic.t rename to src/WattleScript.Tests/TestMore/301-basic.t index 2e165784..93df2e59 100644 --- a/src/MoonSharp.Tests/TestMore/301-basic.t +++ b/src/WattleScript.Tests/TestMore/301-basic.t @@ -27,7 +27,7 @@ L. --]] --- MoonSharp note : THIS SUITE WAS HEAVILY CUT FOR NOT APPLIABLE TESTS +-- WattleScript note : THIS SUITE WAS HEAVILY CUT FOR NOT APPLIABLE TESTS require 'Test.More' @@ -259,7 +259,7 @@ is(rawset(t, 'a', 'letter a'), t, "function rawset") is(t.a, 'letter a') error_like(function () t = {}; rawset(t, nil, 42) end, - "^[^:]+:%d+: table index is nil", -- changed this for MoonSharp, but we stay as it is! + "^[^:]+:%d+: table index is nil", -- changed this for WattleScript, but we stay as it is! "function rawset (table index is nil)") is(select('#'), 0, "function select") @@ -285,7 +285,7 @@ is(type(print), 'function') is(type(type), 'function') is(type(true), 'boolean') is(type(nil), 'nil') --- is(type(io.stdin), 'userdata') -- no stdin in MoonSharp so far +-- is(type(io.stdin), 'userdata') -- no stdin in WattleScript so far is(type(type(X)), 'string') a = nil @@ -346,7 +346,7 @@ error_like(function () tostring() end, "^[^:]+:%d+: bad argument #1 to 'tostring' %(value expected%)", "function tostring (no arg)") ---[[ MoonSharp : this is intentional - we support pack and unpack outside the table namespace (or whatever they are) +--[[ WattleScript : this is intentional - we support pack and unpack outside the table namespace (or whatever they are) if (platform and platform.compat) or jit then type_ok(unpack, 'function', "function unpack") else diff --git a/src/MoonSharp.Tests/TestMore/304-string.t b/src/WattleScript.Tests/TestMore/304-string.t similarity index 99% rename from src/MoonSharp.Tests/TestMore/304-string.t rename to src/WattleScript.Tests/TestMore/304-string.t index f610aaed..aae7b153 100644 --- a/src/MoonSharp.Tests/TestMore/304-string.t +++ b/src/WattleScript.Tests/TestMore/304-string.t @@ -55,7 +55,7 @@ error_like(function () string.char(0, 'bad') end, --[[ -MoonSharp intentional : +WattleScript intentional : 1) unicode chars supported! 2) plan has upvalues, and by Lua spec it shouldn't be supported! diff --git a/src/MoonSharp.Tests/TestMore/305-table.t b/src/WattleScript.Tests/TestMore/305-table.t similarity index 99% rename from src/MoonSharp.Tests/TestMore/305-table.t rename to src/WattleScript.Tests/TestMore/305-table.t index 0c40f3a5..02e30ce8 100644 --- a/src/MoonSharp.Tests/TestMore/305-table.t +++ b/src/WattleScript.Tests/TestMore/305-table.t @@ -225,7 +225,7 @@ eq_array(output, { --[[ -MoonSharp: Sort callbacks work --]] +WattleScript: Sort callbacks work --]] error_like(function () diff --git a/src/MoonSharp.Tests/TestMore/306-math.t b/src/WattleScript.Tests/TestMore/306-math.t similarity index 98% rename from src/MoonSharp.Tests/TestMore/306-math.t rename to src/WattleScript.Tests/TestMore/306-math.t index c68dac55..ca1ae547 100644 --- a/src/MoonSharp.Tests/TestMore/306-math.t +++ b/src/WattleScript.Tests/TestMore/306-math.t @@ -108,7 +108,7 @@ like(math.random(9), '^%d$', "function random 1 arg") like(math.random(10, 19), '^1%d$', "function random 2 arg") --[[ -MoonSharp : math.random normalizes inputs, and we are happy with that +WattleScript : math.random normalizes inputs, and we are happy with that if jit then todo("LuaJIT intentional. Don't check empty interval.", 2) diff --git a/src/MoonSharp.Tests/TestMore/307-bit.t b/src/WattleScript.Tests/TestMore/307-bit.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/307-bit.t rename to src/WattleScript.Tests/TestMore/307-bit.t diff --git a/src/MoonSharp.Tests/TestMore/308-io.t b/src/WattleScript.Tests/TestMore/308-io.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/308-io.t rename to src/WattleScript.Tests/TestMore/308-io.t diff --git a/src/MoonSharp.Tests/TestMore/309-os.t b/src/WattleScript.Tests/TestMore/309-os.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/309-os.t rename to src/WattleScript.Tests/TestMore/309-os.t diff --git a/src/MoonSharp.Tests/TestMore/310-debug.t b/src/WattleScript.Tests/TestMore/310-debug.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/310-debug.t rename to src/WattleScript.Tests/TestMore/310-debug.t diff --git a/src/MoonSharp.Tests/TestMore/314-regex.t b/src/WattleScript.Tests/TestMore/314-regex.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/314-regex.t rename to src/WattleScript.Tests/TestMore/314-regex.t diff --git a/src/MoonSharp.Tests/TestMore/320-stdin.t b/src/WattleScript.Tests/TestMore/320-stdin.t similarity index 100% rename from src/MoonSharp.Tests/TestMore/320-stdin.t rename to src/WattleScript.Tests/TestMore/320-stdin.t diff --git a/src/MoonSharp.Tests/TestMore/Makefile b/src/WattleScript.Tests/TestMore/Makefile similarity index 100% rename from src/MoonSharp.Tests/TestMore/Makefile rename to src/WattleScript.Tests/TestMore/Makefile diff --git a/src/MoonSharp.Tests/TestMore/Modules/Test/Builder.lua b/src/WattleScript.Tests/TestMore/Modules/Test/Builder.lua similarity index 100% rename from src/MoonSharp.Tests/TestMore/Modules/Test/Builder.lua rename to src/WattleScript.Tests/TestMore/Modules/Test/Builder.lua diff --git a/src/MoonSharp.Tests/TestMore/Modules/Test/More.lua b/src/WattleScript.Tests/TestMore/Modules/Test/More.lua similarity index 100% rename from src/MoonSharp.Tests/TestMore/Modules/Test/More.lua rename to src/WattleScript.Tests/TestMore/Modules/Test/More.lua diff --git a/src/MoonSharp.Tests/TestMore/makefile.mak b/src/WattleScript.Tests/TestMore/makefile.mak similarity index 100% rename from src/MoonSharp.Tests/TestMore/makefile.mak rename to src/WattleScript.Tests/TestMore/makefile.mak diff --git a/src/MoonSharp.Tests/TestMoreTests.cs b/src/WattleScript.Tests/TestMoreTests.cs similarity index 99% rename from src/MoonSharp.Tests/TestMoreTests.cs rename to src/WattleScript.Tests/TestMoreTests.cs index 31e44101..82d5c2ac 100644 --- a/src/MoonSharp.Tests/TestMoreTests.cs +++ b/src/WattleScript.Tests/TestMoreTests.cs @@ -4,7 +4,7 @@ using System.Text; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests +namespace WattleScript.Interpreter.Tests { [TestFixture] public class TestMoreTests diff --git a/src/MoonSharp.Tests/TestRunner.cs b/src/WattleScript.Tests/TestRunner.cs similarity index 76% rename from src/MoonSharp.Tests/TestRunner.cs rename to src/WattleScript.Tests/TestRunner.cs index 3c1f79ce..3e6f5fe5 100644 --- a/src/MoonSharp.Tests/TestRunner.cs +++ b/src/WattleScript.Tests/TestRunner.cs @@ -1,4 +1,4 @@ -namespace MoonSharp.Interpreter.Tests; +namespace WattleScript.Interpreter.Tests; public class TestRunner { diff --git a/src/MoonSharp.Tests/TestScript.cs b/src/WattleScript.Tests/TestScript.cs similarity index 97% rename from src/MoonSharp.Tests/TestScript.cs rename to src/WattleScript.Tests/TestScript.cs index b2467635..ecd6521f 100644 --- a/src/MoonSharp.Tests/TestScript.cs +++ b/src/WattleScript.Tests/TestScript.cs @@ -3,10 +3,10 @@ using System.Threading.Tasks; using NUnit.Framework; -namespace MoonSharp.Interpreter.Tests +namespace WattleScript.Interpreter.Tests { - [MoonSharpUserData] + [WattleScriptUserData] public class LuaAssertApi { string GetFailMessage(ScriptExecutionContext executionContext, CallbackArguments args, int skip) diff --git a/src/MoonSharp.Tests/MoonSharp.Tests.csproj b/src/WattleScript.Tests/WattleScript.Tests.csproj similarity index 89% rename from src/MoonSharp.Tests/MoonSharp.Tests.csproj rename to src/WattleScript.Tests/WattleScript.Tests.csproj index 3917f247..7f0a0f9a 100644 --- a/src/MoonSharp.Tests/MoonSharp.Tests.csproj +++ b/src/WattleScript.Tests/WattleScript.Tests.csproj @@ -15,7 +15,7 @@ - + diff --git a/src/MoonSharp.sln b/src/WattleScript.sln similarity index 86% rename from src/MoonSharp.sln rename to src/WattleScript.sln index 0b1e1bd5..2c1d908a 100644 --- a/src/MoonSharp.sln +++ b/src/WattleScript.sln @@ -3,15 +3,15 @@ Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 15 VisualStudioVersion = 15.0.26124.0 MinimumVisualStudioVersion = 15.0.26124.0 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MoonSharp", "MoonSharp\MoonSharp.csproj", "{E46795F2-998D-44E8-B762-9A687AD1E64A}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WattleScript", "WattleScript\WattleScript.csproj", "{E46795F2-998D-44E8-B762-9A687AD1E64A}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MoonSharp.Interpreter", "MoonSharp.Interpreter\MoonSharp.Interpreter.csproj", "{D71FA83B-E6C7-4AC4-A59E-7124803E58A6}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WattleScript.Interpreter", "WattleScript.Interpreter\WattleScript.Interpreter.csproj", "{D71FA83B-E6C7-4AC4-A59E-7124803E58A6}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MoonSharp.Hardwire", "MoonSharp.Hardwire\MoonSharp.Hardwire.csproj", "{DF737944-E700-4C41-AE0F-03F4A291C2DE}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WattleScript.Hardwire", "WattleScript.Hardwire\WattleScript.Hardwire.csproj", "{DF737944-E700-4C41-AE0F-03F4A291C2DE}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MoonSharp.HardwireGen", "MoonSharp.HardwireGen\MoonSharp.HardwireGen.csproj", "{961B856C-A72C-4D89-903C-2B801B348FD2}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WattleScript.HardwireGen", "WattleScript.HardwireGen\WattleScript.HardwireGen.csproj", "{961B856C-A72C-4D89-903C-2B801B348FD2}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MoonSharp.Tests", "MoonSharp.Tests\MoonSharp.Tests.csproj", "{416B592B-1943-4379-8824-5D9EC62484A7}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WattleScript.Tests", "WattleScript.Tests\WattleScript.Tests.csproj", "{416B592B-1943-4379-8824-5D9EC62484A7}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/src/MoonSharp/Commands/CommandManager.cs b/src/WattleScript/Commands/CommandManager.cs similarity index 96% rename from src/MoonSharp/Commands/CommandManager.cs rename to src/WattleScript/Commands/CommandManager.cs index 3a7ec0cc..0dcbeefa 100644 --- a/src/MoonSharp/Commands/CommandManager.cs +++ b/src/WattleScript/Commands/CommandManager.cs @@ -4,7 +4,7 @@ using System.Reflection; using System.Text; -namespace MoonSharp.Commands +namespace WattleScript.Commands { static class CommandManager { diff --git a/src/MoonSharp/Commands/ICommand.cs b/src/WattleScript/Commands/ICommand.cs similarity index 88% rename from src/MoonSharp/Commands/ICommand.cs rename to src/WattleScript/Commands/ICommand.cs index 799bca5a..d8168918 100644 --- a/src/MoonSharp/Commands/ICommand.cs +++ b/src/WattleScript/Commands/ICommand.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Commands +namespace WattleScript.Commands { interface ICommand { diff --git a/src/MoonSharp/Commands/Implementations/CompileCommand.cs b/src/WattleScript/Commands/Implementations/CompileCommand.cs similarity index 91% rename from src/MoonSharp/Commands/Implementations/CompileCommand.cs rename to src/WattleScript/Commands/Implementations/CompileCommand.cs index 895741f2..6468b566 100644 --- a/src/MoonSharp/Commands/Implementations/CompileCommand.cs +++ b/src/WattleScript/Commands/Implementations/CompileCommand.cs @@ -3,9 +3,9 @@ using System.IO; using System.Linq; using System.Text; -using MoonSharp.Interpreter; +using WattleScript.Interpreter; -namespace MoonSharp.Commands.Implementations +namespace WattleScript.Commands.Implementations { class CompileCommand : ICommand { diff --git a/src/MoonSharp/Commands/Implementations/DumpBytecodeCommand.cs b/src/WattleScript/Commands/Implementations/DumpBytecodeCommand.cs similarity index 92% rename from src/MoonSharp/Commands/Implementations/DumpBytecodeCommand.cs rename to src/WattleScript/Commands/Implementations/DumpBytecodeCommand.cs index 6d5c1246..9bd4f400 100644 --- a/src/MoonSharp/Commands/Implementations/DumpBytecodeCommand.cs +++ b/src/WattleScript/Commands/Implementations/DumpBytecodeCommand.cs @@ -3,9 +3,9 @@ using System.IO; using System.Linq; using System.Text; -using MoonSharp.Interpreter; +using WattleScript.Interpreter; -namespace MoonSharp.Commands.Implementations +namespace WattleScript.Commands.Implementations { class DumpBytecodeCommand : ICommand { diff --git a/src/MoonSharp/Commands/Implementations/ExitCommand.cs b/src/WattleScript/Commands/Implementations/ExitCommand.cs similarity index 90% rename from src/MoonSharp/Commands/Implementations/ExitCommand.cs rename to src/WattleScript/Commands/Implementations/ExitCommand.cs index 0cb0bfe8..d445ffc0 100644 --- a/src/MoonSharp/Commands/Implementations/ExitCommand.cs +++ b/src/WattleScript/Commands/Implementations/ExitCommand.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Commands.Implementations +namespace WattleScript.Commands.Implementations { class ExitCommand : ICommand { diff --git a/src/MoonSharp/Commands/Implementations/HardWireCommand.cs b/src/WattleScript/Commands/Implementations/HardWireCommand.cs similarity index 96% rename from src/MoonSharp/Commands/Implementations/HardWireCommand.cs rename to src/WattleScript/Commands/Implementations/HardWireCommand.cs index 078d0f61..06955976 100644 --- a/src/MoonSharp/Commands/Implementations/HardWireCommand.cs +++ b/src/WattleScript/Commands/Implementations/HardWireCommand.cs @@ -3,11 +3,11 @@ using System.IO; using System.Linq; using System.Text; -using MoonSharp.Hardwire; -using MoonSharp.Hardwire.Languages; -using MoonSharp.Interpreter; +using WattleScript.Hardwire; +using WattleScript.Hardwire.Languages; +using WattleScript.Interpreter; -namespace MoonSharp.Commands.Implementations +namespace WattleScript.Commands.Implementations { class HardWireCommand : ICommand { diff --git a/src/MoonSharp/Commands/Implementations/HelpCommand.cs b/src/WattleScript/Commands/Implementations/HelpCommand.cs similarity index 97% rename from src/MoonSharp/Commands/Implementations/HelpCommand.cs rename to src/WattleScript/Commands/Implementations/HelpCommand.cs index 6536d5ab..d0f61370 100644 --- a/src/MoonSharp/Commands/Implementations/HelpCommand.cs +++ b/src/WattleScript/Commands/Implementations/HelpCommand.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Commands +namespace WattleScript.Commands { class HelpCommand : ICommand { diff --git a/src/MoonSharp/Commands/Implementations/RegisterCommand.cs b/src/WattleScript/Commands/Implementations/RegisterCommand.cs similarity index 91% rename from src/MoonSharp/Commands/Implementations/RegisterCommand.cs rename to src/WattleScript/Commands/Implementations/RegisterCommand.cs index ded5aa9c..341210b9 100644 --- a/src/MoonSharp/Commands/Implementations/RegisterCommand.cs +++ b/src/WattleScript/Commands/Implementations/RegisterCommand.cs @@ -2,9 +2,9 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using MoonSharp.Interpreter; +using WattleScript.Interpreter; -namespace MoonSharp.Commands.Implementations +namespace WattleScript.Commands.Implementations { class RegisterCommand : ICommand { diff --git a/src/MoonSharp/Commands/Implementations/RunCommand.cs b/src/WattleScript/Commands/Implementations/RunCommand.cs similarity index 92% rename from src/MoonSharp/Commands/Implementations/RunCommand.cs rename to src/WattleScript/Commands/Implementations/RunCommand.cs index 31e1e481..692ec889 100644 --- a/src/MoonSharp/Commands/Implementations/RunCommand.cs +++ b/src/WattleScript/Commands/Implementations/RunCommand.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; -namespace MoonSharp.Commands.Implementations +namespace WattleScript.Commands.Implementations { class RunCommand : ICommand { diff --git a/src/MoonSharp/Program.cs b/src/WattleScript/Program.cs similarity index 88% rename from src/MoonSharp/Program.cs rename to src/WattleScript/Program.cs index d6aa804c..c1c657d5 100755 --- a/src/MoonSharp/Program.cs +++ b/src/WattleScript/Program.cs @@ -5,15 +5,15 @@ using System.Linq; using System.Reflection; using System.Text; -using MoonSharp.Commands; -using MoonSharp.Commands.Implementations; -using MoonSharp.Interpreter; -using MoonSharp.Interpreter.Execution; -using MoonSharp.Interpreter.Loaders; -using MoonSharp.Interpreter.REPL; -using MoonSharp.Interpreter.Serialization; - -namespace MoonSharp +using WattleScript.Commands; +using WattleScript.Commands.Implementations; +using WattleScript.Interpreter; +using WattleScript.Interpreter.Execution; +using WattleScript.Interpreter.Loaders; +using WattleScript.Interpreter.REPL; +using WattleScript.Interpreter.Serialization; + +namespace WattleScript { class Program { @@ -168,7 +168,7 @@ private static bool CheckArgs(string[] args, ShellContext shellContext) private static void ShowCmdLineHelpBig() { - Console.WriteLine("usage: moonsharp [-H | --help | -X \"command\" | -W [--internals] [--vb] [--class:] [--namespace:] |