Simple content resolving implementation

elamaunt · Jul 29, 2021 · 855a31f · 855a31f
1 parent 5619961
commit 855a31f
Show file tree

Hide file tree

Showing 3 changed files with 103 additions and 14 deletions.
diff --git a/src/GDShrapt.Reader.Tests/ParsingTests.cs b/src/GDShrapt.Reader.Tests/ParsingTests.cs
@@ -1522,5 +1522,29 @@ public void NewLineParsingTest1()
 
             AssertHelper.CompareCodeStrings(code, statement.ToString());
         }
+
+        [TestMethod]
+        public void UnspecifiedContentParsingTest()
+        {
+            var reader = new GDScriptReader();
+
+            var code1 = "tool";
+            var code2 = "var a = b + c";
+            var code3 = "for a in [0,1,2]: print(\"Hello\")";
+
+            var nodes1 = reader.ParseUnspecifiedContent(code1);
+            var nodes2 = reader.ParseUnspecifiedContent(code2);
+            var nodes3 = reader.ParseUnspecifiedContent(code3);
+
+            Assert.AreEqual(1, nodes1.Count);
+            Assert.AreEqual(1, nodes2.Count);
+            Assert.AreEqual(1, nodes3.Count);
+
+            Assert.IsInstanceOfType(nodes1[0], typeof(GDClassDeclaration));
+            Assert.IsInstanceOfType(nodes2[0], typeof(GDClassDeclaration));
+            Assert.IsInstanceOfType(nodes3[0], typeof(GDStatementsList));
+
+            Assert.IsInstanceOfType(((GDStatementsList)nodes3[0])[0], typeof(GDForStatement));
+        }
     }
 }
diff --git a/src/GDShrapt.Reader/GDScriptReader.cs b/src/GDShrapt.Reader/GDScriptReader.cs
@@ -106,8 +106,7 @@ public GDStatement ParseStatement(string content)
 
         public List<GDSyntaxToken> ParseUnspecifiedContent(string content)
         {
-            throw new NotImplementedException();
-            /*var state = new GDReadingState(Settings);
+            var state = new GDReadingState(Settings);
             var receiver = new GDReceiver();
 
             state.Push(new GDContentResolver(receiver));
@@ -122,7 +121,7 @@ public List<GDSyntaxToken> ParseUnspecifiedContent(string content)
             }
 
             state.CompleteReading();
-            return receiver.Tokens;*/
+            return receiver.Tokens;
         }
 
         private void ParseBuffer(char[] buffer, int count, GDReadingState state)

diff --git a/src/GDShrapt.Reader/Resolvers/GDContentResolver.cs b/src/GDShrapt.Reader/Resolvers/GDContentResolver.cs
@@ -19,16 +19,15 @@ public GDContentResolver(IIntendedTokenReceiver<GDNode> owner)
 
         internal override void HandleCharAfterIntendation(char c, GDReadingState state)
         {
-            if (char.IsLetter(c) || c == '_')
+            if (char.IsLetter(c) || c == '_' || (_sequence.Length > 0 && char.IsDigit(c)))
             {
                 _sequence.Append(c);
                 return;
             }
 
             if (_sequence.Length > 0)
             {
-                HandleSequence(_sequence.ToString());
-                _sequence.Clear();
+                HandleSequence(_sequence.ToString(), state);
                 state.PassChar(c);
                 return;
             }
@@ -39,17 +38,64 @@ internal override void HandleCharAfterIntendation(char c, GDReadingState state)
                 return;
             }
 
-            // statements
-            //state.Pop();
+            Owner.HandleReceivedToken(state.PushAndPass(new GDStatementsList(), c));
+        }
 
-            state.PushAndPass(new GDStatementsList(), c);
+        private void HandleSequence(string seq, GDReadingState state)
+        {
+            _sequence.Clear();
 
+            if (CalculatedIntendation > 0)
+            {
+                switch (seq)
+                {
+                    case "var":
+                    case "func":
+                    case "signal":
+                    case "const":
+                    case "class":
+                    case "static":
+                    case "onready":
+                        Owner.HandleReceivedToken(state.Push(new GDInnerClassDeclaration(CalculatedIntendation)));
+                        break;
+                    default:
+                        Owner.HandleReceivedToken(state.Push(new GDStatementsList()));
+                        break;
+                }
 
-        }
+                PassIntendationSequence(state);
+            }
+            else
+            {
+                switch (seq)
+                {
+                    case "extends":
+                    case "class_name":
+                    case "tool":
+                    case "var":
+                    case "func":
+                    case "const":
+                    case "signal":
+                    case "export":
+                    case "class":
+                    case "static":
+                    case "onready":
+                        Owner.HandleReceivedToken(state.Push(new GDClassDeclaration()));
+                        break;
+                    default:
+                        Owner.HandleReceivedToken(state.Push(new GDStatementsList()));
+                        break;
+                }
+            }
 
-        private void HandleSequence(string seq)
-        {
+            if (_lastSpace != null)
+            {
+                state.PassString(_lastSpace.ToString());
+                _lastSpace = null;
+            }
 
+            ResetIntendation();
+            state.PassString(seq);
         }
 
         internal override void HandleNewLineAfterIntendation(GDReadingState state)
@@ -66,7 +112,8 @@ internal override void HandleNewLineAfterIntendation(GDReadingState state)
             }
             else
             {
-                HandleSequence(_sequence.ToString());
+                HandleSequence(_sequence.ToString(), state);
+                state.PassNewLine();
             }
         }
 
@@ -84,8 +131,27 @@ internal override void HandleSharpCharAfterIntendation(GDReadingState state)
             }
             else
             {
-                HandleSequence(_sequence.ToString());
+                HandleSequence(_sequence.ToString(), state);
+                state.PassSharpChar();
             }
         }
+
+        internal override void ForceComplete(GDReadingState state)
+        {
+            if (_sequence.Length > 0)
+            {
+                HandleSequence(_sequence.ToString(), state);
+            }
+            else
+            {
+                if (_lastSpace != null)
+                {
+                    Owner.HandleReceivedToken(_lastSpace);
+                    _lastSpace = null;
+                }
+            }
+
+            base.ForceComplete(state);
+        }
     }
 }