ДЗ

Spring/.gitignore

@@ -1,7 +1,7 @@
 RiderSdkPackageVersion.props
 
 # Generated files
-*Generated.cs
+Generated.cs
 *Generated.fs
 
 # Build results

Spring/Spring.sln.DotSettings.user

@@ -0,0 +1,4 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=5c1f3cd4_002D0626_002D4aaa_002D89b9_002D568868ab3c32/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" Name="All tests from ZoneMarker.cs" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;&#xD;
+  &lt;ProjectFile&gt;465BE399-F1C5-4B6C-A77A-79390C45F8DB/d:src/f:ZoneMarker.cs&lt;/ProjectFile&gt;&#xD;
+&lt;/SessionState&gt;</s:String></wpf:ResourceDictionary>

Spring/src/Spring/src/Sample.lex

@@ -18,6 +18,8 @@ TokenNodeType currentTokenType;
 %namespace Sample
 %class SampleLexerGenerated
 
+%implements ILexer
+
 %function _locateToken
 %public
 %type TokenNodeType
@@ -27,20 +29,33 @@ TokenNodeType currentTokenType;
   currentTokenType = null; return currentTokenType;
 %eofval}
 
-
 ALPHA=[A-Za-z]
 DIGIT=[0-9]
 NEWLINE=((\r\n)|\n)
 NONNEWLINE_WHITE_SPACE_CHAR=[\ \t\b\012]
-WHITE_SPACE_CHAR=[{NEWLINE}\ \t\b\012]
+WHITE_SPACE_CHAR=({NEWLINE}|[\ \t\b\012])
 STRING_TEXT="\""(.)*"\""
-STRING_TEXT2="\""(.)*"xx"
 
 
 
 %% 
-<YYINITIAL> "=" { return currentTokenType = SpringTokenType.EQ; }
+<YYINITIAL> {WHITE_SPACE_CHAR}* { return currentTokenType = SpringTokenType.WHITE_SPACE; }
+<YYINITIAL> for { return currentTokenType = SpringTokenType.FOR; }
+<YYINITIAL> read { return currentTokenType = SpringTokenType.READ; }
+<YYINITIAL> write { return currentTokenType = SpringTokenType.WRITE; }
+<YYINITIAL> if { return currentTokenType = SpringTokenType.IF; }
+<YYINITIAL> else { return currentTokenType = SpringTokenType.ELSE; }
+<YYINITIAL> ":=" { return currentTokenType = SpringTokenType.ASSIGN; }
+<YYINITIAL> ["><="] { return currentTokenType = SpringTokenType.LOGIC_BINOP; }
+<YYINITIAL> ["+-"] { return currentTokenType = SpringTokenType.LOW_BINOP; }
+<YYINITIAL> ["*/"] { return currentTokenType = SpringTokenType.MEDIUM_BINOP; }
+<YYINITIAL> "^" { return currentTokenType = SpringTokenType.HIGH_BINOP; }
+<YYINITIAL> {ALPHA}+ { return currentTokenType = SpringTokenType.IDENT; }
+<YYINITIAL> "(" { return currentTokenType = SpringTokenType.LBRACKET; }
+<YYINITIAL> ")" { return currentTokenType = SpringTokenType.RBRACKET; }
+<YYINITIAL> "{" { return currentTokenType = SpringTokenType.LFBRACKET; }
+<YYINITIAL> "}" { return currentTokenType = SpringTokenType.RFBRACKET; }
+<YYINITIAL> ";" { return currentTokenType = SpringTokenType.SEQ; }
 <YYINITIAL> {DIGIT}+ { return currentTokenType = SpringTokenType.NUMBER; }	
 <YYINITIAL> {STRING_TEXT} { return currentTokenType = SpringTokenType.STRING; }	
-<YYINITIAL> {STRING_TEXT2} { return currentTokenType = SpringTokenType.NUMBER; }	
 <YYINITIAL> . { return currentTokenType = SpringTokenType.BAD_CHARACTER; }	

Spring/src/Spring/src/SampleLexerGenerated.cs

@@ -0,0 +1,129 @@
+namespace Sample
+{
+using System;
+using JetBrains.ReSharper.Psi.Parsing;
+using JetBrains.Text;
+using JetBrains.Util;
+using JetBrains.ReSharper.Plugins.Spring;
+
+
+public  partial class SampleLexerGenerated : ILexer
+{
+
+  private TokenNodeType myCurrentTokenType = SpringTokenType.BAD_CHARACTER;
+
+  public void Start()
+  {
+    Start(0, yy_buffer.Length, YYINITIAL);
+  }
+
+  public void Start(int startOffset, int endOffset, uint state)
+  {
+    yy_buffer_index = startOffset;
+    yy_buffer_start = startOffset;
+    yy_buffer_end = startOffset;
+    yy_eof_pos = endOffset;
+    yy_lexical_state = (int) state;
+    myCurrentTokenType = null;
+  }
+
+  public void Advance()
+  {
+    myCurrentTokenType = null;
+    LocateToken();
+  }
+
+  public struct TokenPosition
+  {
+    public TokenNodeType CurrentTokenType;
+    public int YyBufferIndex;
+    public int YyBufferStart;
+    public int YyBufferEnd;
+    public int YyLexicalState;
+  }
+
+  public object CurrentPosition
+  {
+    get
+    {
+      TokenPosition tokenPosition;
+      tokenPosition.CurrentTokenType = myCurrentTokenType;
+      tokenPosition.YyBufferIndex = yy_buffer_index;
+      tokenPosition.YyBufferStart = yy_buffer_start;
+      tokenPosition.YyBufferEnd = yy_buffer_end;
+      tokenPosition.YyLexicalState = yy_lexical_state;
+      return tokenPosition;
+    }
+    set
+    {
+      var tokenPosition = (TokenPosition) value;
+      myCurrentTokenType = tokenPosition.CurrentTokenType;
+      yy_buffer_index = tokenPosition.YyBufferIndex;
+      yy_buffer_start = tokenPosition.YyBufferStart;
+      yy_buffer_end = tokenPosition.YyBufferEnd;
+      yy_lexical_state = tokenPosition.YyLexicalState;
+    }
+  }
+
+  public TokenNodeType TokenType
+  {
+    get
+    {
+      LocateToken();
+      return myCurrentTokenType;
+    }
+  }
+
+  public int TokenStart
+  {
+    get
+    {
+      LocateToken();
+      return yy_buffer_start;
+    }
+  }
+
+  public int TokenEnd
+  {
+    get
+    {
+      LocateToken();
+      return yy_buffer_end;
+    }
+  }
+
+  public IBuffer Buffer
+  {
+    get
+    {
+      return yy_buffer;
+    }
+  }
+
+  public uint LexerStateEx
+  {
+    get
+    {
+      return (uint) yy_lexical_state;
+    }
+  }
+
+  public int LexemIndent { get { return 7; } }
+  public int EOFPos { get { return yy_eof_pos; } }
+
+  private void LocateToken()
+  {
+    if (myCurrentTokenType == null)
+    {
+      myCurrentTokenType = _locateToken();
+    }
+  }
+
+  private TokenNodeType makeToken(TokenNodeType type)
+  {
+    return myCurrentTokenType = type;
+  }
+
+}
+
+}

Spring/src/Spring/src/SpringFile.cs

@@ -10,9 +10,93 @@ public class SpringFile : FileElementBase
         public override PsiLanguageType Language => SpringLanguage.Instance;
     }
 
-    public class SpringBlock : CompositeElement
+    public class SpringSeq : CompositeElement
     {
-        public override NodeType NodeType => SpringCompositeNodeType.BLOCK;
+        public override NodeType NodeType => SpringCompositeNodeType.SEQ;
+
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+    }
+
+    public class SpringAssign : CompositeElement
+    {
+        public override NodeType NodeType => SpringCompositeNodeType.ASSIGN;
+
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+    }
+
+    public class SpringLowBinop : CompositeElement
+    {
+        public override NodeType NodeType => SpringCompositeNodeType.LOW_BINOP;
+
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+    }
+
+    public class SpringMediumBinop : CompositeElement
+    {
+        public override NodeType NodeType => SpringCompositeNodeType.MEDIUM_BINOP;
+
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+    }
+
+    public class SpringHighBinop : CompositeElement
+    {
+        public override NodeType NodeType => SpringCompositeNodeType.HIGH_BINOP;
+
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+    }
+
+    public class SpringNumber : CompositeElement
+    {
+        public override NodeType NodeType => SpringCompositeNodeType.NUMBER;
+
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+    }
+
+    public class SpringVariable : CompositeElement
+    {
+        public override NodeType NodeType => SpringCompositeNodeType.VARIABLE;
+
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+    }
+
+    public class SpringString : CompositeElement
+    {
+        public override NodeType NodeType => SpringCompositeNodeType.STRING;
+
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+    }
+
+    public class SpringLogicBinop : CompositeElement
+    {
+        public override NodeType NodeType => SpringCompositeNodeType.LOGIC_BINOP;
+
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+    }
+
+    public class SpringFor : CompositeElement
+    {
+        public override NodeType NodeType => SpringCompositeNodeType.FOR;
+
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+    }
+
+    public class SpringRead : CompositeElement
+    {
+        public override NodeType NodeType => SpringCompositeNodeType.READ;
+
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+    }
+
+    public class SpringWrite : CompositeElement
+    {
+        public override NodeType NodeType => SpringCompositeNodeType.WRITE;
+
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+    }
+
+    public class SpringIf : CompositeElement
+    {
+        public override NodeType NodeType => SpringCompositeNodeType.IF;
 
         public override PsiLanguageType Language => SpringLanguage.Instance;
     }

Spring/src/Spring/src/SpringFileNodeType.cs

@@ -21,15 +21,49 @@ internal class SpringCompositeNodeType : CompositeNodeType
         public SpringCompositeNodeType(string s, int index) : base(s, index)
         {
         }
-        public static readonly SpringCompositeNodeType BLOCK = new SpringCompositeNodeType("Spring_BLOCK", 0);
-        public static readonly SpringCompositeNodeType OTHER = new SpringCompositeNodeType("Spring_OTHER", 1);
+        public static readonly SpringCompositeNodeType SEQ = new SpringCompositeNodeType("Spring_SEQ", 0);
+        public static readonly SpringCompositeNodeType ASSIGN = new SpringCompositeNodeType("Spring_ASSIGN", 1);
+        public static readonly SpringCompositeNodeType LOW_BINOP = new SpringCompositeNodeType("Spring_LOW_BINOP", 2);
+        public static readonly SpringCompositeNodeType MEDIUM_BINOP = new SpringCompositeNodeType("Spring_MEDIUM_BINOP", 3);
+        public static readonly SpringCompositeNodeType HIGH_BINOP = new SpringCompositeNodeType("Spring_HIGH_BINOP", 4);
+        public static readonly SpringCompositeNodeType NUMBER = new SpringCompositeNodeType("Spring_NUMBER", 5);
+        public static readonly SpringCompositeNodeType VARIABLE = new SpringCompositeNodeType("Spring_VARIABLE", 6);
+        public static readonly SpringCompositeNodeType STRING = new SpringCompositeNodeType("Spring_STRING", 7);
+        public static readonly SpringCompositeNodeType FOR = new SpringCompositeNodeType("Spring_FOR", 8);
+        public static readonly SpringCompositeNodeType LOGIC_BINOP = new SpringCompositeNodeType("Spring_LOGIC_BINOP", 9);
+        public static readonly SpringCompositeNodeType READ = new SpringCompositeNodeType("Spring_READ", 10);
+        public static readonly SpringCompositeNodeType WRITE = new SpringCompositeNodeType("Spring_WRITE", 11);
+        public static readonly SpringCompositeNodeType IF = new SpringCompositeNodeType("Spring_IF", 12);
 
         public override CompositeElement Create()
         {
-            if (this == BLOCK)
-                return new SpringBlock();
-            else 
-                throw new InvalidOperationException();
+            if (this == SEQ)
+                return new SpringSeq();
+            if (this == ASSIGN)
+                return new SpringAssign();
+            if (this == LOW_BINOP)
+                return new SpringLowBinop();
+            if (this == MEDIUM_BINOP)
+                return new SpringMediumBinop();
+            if (this == HIGH_BINOP)
+                return new SpringHighBinop();
+            if (this == NUMBER)
+                return new SpringNumber();
+            if (this == VARIABLE)
+                return new SpringVariable();
+            if (this == STRING)
+                return new SpringString();
+            if (this == FOR)
+                return new SpringFor();
+            if (this == LOGIC_BINOP)
+                return new SpringLogicBinop();
+            if (this == READ)
+                return new SpringRead();
+            if (this == WRITE)
+                return new SpringWrite();
+            if (this == IF)
+                return new SpringIf();
+            throw new InvalidOperationException();
         }
     }
 

Spring/src/Spring/src/SpringGenericToken.cs

@@ -0,0 +1,49 @@
+using System.Text;
+using JetBrains.ReSharper.Psi;
+using JetBrains.ReSharper.Psi.ExtensionsAPI.Tree;
+using JetBrains.ReSharper.Psi.Parsing;
+using JetBrains.ReSharper.Psi.Tree;
+using JetBrains.Text;
+
+namespace JetBrains.ReSharper.Plugins.Spring
+{
+    public class SpringGenericToken : LeafElementBase, ITokenNode
+    {
+        private readonly TokenNodeType myTokenType;
+        private readonly string myText;
+
+        public SpringGenericToken(TokenNodeType tokenType, string text)
+        {
+            myTokenType = tokenType;
+            myText = text ?? string.Empty;
+        }
+
+        public override int GetTextLength()
+        {
+            return myText.Length;
+        }
+
+        public override StringBuilder GetText(StringBuilder to)
+        {
+            to.Append(GetText());
+            return to;
+        }
+
+        public override IBuffer GetTextAsBuffer()
+        {
+            return new StringBuffer(myText);
+        }
+
+        public override string GetText()
+        {
+            return myText;
+        }
+
+        public override NodeType NodeType => myTokenType;
+        public override PsiLanguageType Language => SpringLanguage.Instance;
+        public TokenNodeType GetTokenType()
+        {
+            return myTokenType;
+        }
+    }
+}