implab/ImplabNet Commit - r59:21611344d366

code cleanup

cin -

r59:21611344d366 default

parent child

Context file:

r59:21611344d366

Collapse all files

Implab/Implab.csproj +1 0

                  <ErrorReport>prompt</ErrorReport>
                  <WarningLevel>4</WarningLevel>
                  <ConsolePause>false</ConsolePause>
+                 <RunCodeAnalysis>true</RunCodeAnalysis>
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                  <DebugType>full</DebugType>

Implab/JSON/JSONParser.cs +53 -1

              using System;
              using System.Collections.Generic;
              using System.Diagnostics;
+             using System.IO;
              using System.Linq;
              using System.Text;
              using System.Threading.Tasks;
                  /// <summary>
                  /// Pull парсер JSON данных.
                  /// </summary>
-                 public class JSONParser : DFAutomaton<JSONParserContext> {
+                 public class JSONParser : DFAutomaton<JSONParserContext>, IDisposable {
                      enum MemberContext {
                          MemberName,
                      JSONElementType m_elementType;
                      object m_elementValue;
+                     /// <summary>
+                     /// Создает новый парсер на основе строки, содержащей JSON
+                     /// </summary>
+                     /// <param name="text"></param>
                      public JSONParser(string text)
-                         : base(_jsonDFA, INITIAL_STATE, new JSONParserContext { elementContext = JSONElementContext.None, memberName = String.Empty } ) {
                          Safe.ArgumentNotEmpty(text, "text");
                          m_scanner.Feed(text.ToCharArray());
                      }
+                     /// <summary>
+                     /// Создает новый экземпляр парсера, на основе текстового потока.
+                     /// </summary>
+                     /// <param name="reader">Текстовый поток.</param>
+                     /// <param name="dispose">Признак того, что парсер должен конролировать время жизни входного потока.</param>
+                     public JSONParser(TextReader reader, bool dispose)
+                         : base(_jsonDFA, INITIAL_STATE, new JSONParserContext { elementContext = JSONElementContext.None, memberName = String.Empty }) {
+                         Safe.ArgumentNotNull(reader, "reader");
+                         m_scanner = new JSONScanner();
+                         m_scanner.Feed(reader, dispose);
+                     }
+                     /// <summary>
+                     /// Тип текущего элемента на котором стоит парсер.
+                     /// </summary>
                      public JSONElementType ElementType {
                          get { return m_elementType; }
                      }
+                     /// <summary>
+                     /// Имя элемента - имя свойства родительского контейнера. Для элементов массивов и корневого всегда
+                     /// пустая строка.
+                     /// </summary>
                      public string ElementName {
                          get { return m_context.info.memberName; }
                      }
+                     /// <summary>
+                     /// Значение элемента. Только для элементов типа <see cref="JSONElementType.Value"/>, для остальных <c>null</c>
+                     /// </summary>
                      public object ElementValue {
                          get { return m_elementValue; }
                      }
+                     /// <summary>
+                     /// Читает слеюудущий объект из потока
+                     /// </summary>
+                     /// <returns><c>true</c> - операция чтения прошла успешно, <c>false</c> - конец данных</returns>
                      public bool Read() {
                          if (m_context.current == UNREACHEBLE_STATE)
                              throw new InvalidOperationException("The parser is in invalid state");
                      }
+                     /// <summary>
+                     /// Признак конца потока
+                     /// </summary>
                      public bool EOF {
                          get {
                              return m_scanner.EOF;
                          }
                      }
+                     protected virtual void Dispose(bool disposing) {
+                         if (disposing) {
+                             m_scanner.Dispose();
+                         }
+                     }
+                     /// <summary>
+                     /// Освобождает парсер и связанный с ним сканнер.
+                     /// </summary>
+                     public void Dispose() {
+                         Dispose(true);
+                         GC.SuppressFinalize(this);
+                     }
+                     ~JSONParser() {
+                         Dispose(false);
+                     }
                  }
              }

Implab/JSON/JSONXmlReader.cs +10 -2

                      }
                      public override void Close() {
-                         m_state = System.Xml.ReadState.EndOfFile ;
+                     }
+                     protected override void Dispose(bool disposing) {
+                         if (disposing) {
+                             m_parser.Dispose();
+                         }
+                         base.Dispose(disposing);
+                     }
-                     }
                  }
+             }

Implab/Parsing/Alphabet.cs +4 -4

              namespace Implab.Parsing {
                  public class Alphabet: AlphabetBase<char> {
+                     public Alphabet()
+                         : base(char.MaxValue + 1) {
+                     }
                      public override int GetSymbolIndex(char symbol) {
                          return symbol;
                      }
                      public override IEnumerable<char> InputSymbols {
                          get { return Enumerable.Range(char.MinValue, char.MaxValue).Select(x => (char)x); }
                      }
-                     protected override int MapSize {
-                         get { return char.MaxValue + 1; }
-                     }
                  }
+             }

Implab/Parsing/AlphabetBase.cs +2 -5

                          get { return m_nextId; }
                      }
-                     protected AlphabetBase() {
-                         m_map = new int[MapSize];
+                     protected AlphabetBase(int mapSize) {
+                         m_map = new int[mapSize];
                      }
                      protected AlphabetBase(int[] map) {
                          Debug.Assert(map != null);
-                         Debug.Assert(map.Length == MapSize);
                          m_map = map;
                          m_nextId = map.Max() + 1;
                      public abstract IEnumerable<T> InputSymbols { get; }
-                     protected abstract int MapSize { get; }
                      public int[] GetTranslationMap() {
                          return m_map;
                      }

Implab/Parsing/EnumAlphabet.cs +3 -4

              using Implab;
              using System;
              using System.Collections.Generic;
+             using System.Diagnostics;
              using System.Globalization;
              using System.Linq;
              using System.Text;
                      public EnumAlphabet()
-                         : base() {
+                         : base(_symbols.Length) {
                      }
                      public EnumAlphabet(int[] map)
                          : base(map) {
+                         Debug.Assert(map.Length == _symbols.Length);
                      }
                          get { return _symbols; }
                      }
-                     protected override int MapSize {
-                         get { return _symbols.Length; }
-                     }
                  }
+             }

Implab/Parsing/Scanner.cs +61 -18

              using Implab;
              using System;
              using System.Collections.Generic;
+             using System.IO;
              using System.Linq;
              using System.Text;
              using System.Threading.Tasks;
                  /// указателя, начала и конца токена, при перемещении искользуется ДКА для определения
                  /// конца токена и допустимости текущего символа.
                  /// </remarks>
-                 public class Scanner {
+                 public abstract class Scanner : Disposable {
                      struct ScannerConfig {
                          public DFAStateDescriptior[] states;
                          public int[] alphabetMap;
                      protected int m_bufferSize;
                      protected int m_pointer;
-                     public Scanner(CDFADefinition definition, string text) {
-                         Safe.ArgumentNotNull(definition, "definition");
-                         Safe.ArgumentNotEmpty(text, "text");
-                         m_states = definition.States;
-                         m_alphabetMap = definition.Alphabet.GetTranslationMap();
-                         Feed(text.ToCharArray());
+                     }
+                     TextReader m_reader;
+                     bool m_disposeReader;
+                     int m_chunkSize = 1024; // 1k
+                     int m_limit = 10 * 1024 * 1024; // 10Mb
                      public Scanner(CDFADefinition definition) {
                          Safe.ArgumentNotNull(definition, "definition");
                      public void Feed(char[] data, int length) {
                          Safe.ArgumentNotNull(data, "data");
                          Safe.ArgumentInRange(length, 0, data.Length, "length");
+                         AssertNotDisposed();
                          m_pointer = -1;
                          m_buffer = data;
                          Shift();
                      }
+                     public void Feed(TextReader reader, bool dispose) {
+                         Safe.ArgumentNotNull(reader, "reader");
+                         AssertNotDisposed();
+                         if (m_reader != null && m_disposeReader)
+                             m_reader.Dispose();
+                         m_reader = reader;
+                         m_disposeReader = dispose;
+                         m_pointer = -1;
+                         m_buffer = new char[m_chunkSize];
+                         m_bufferSize = 0;
+                         Shift();
+                     }
                      /// <summary>
                      /// Получает текущий токен в виде строки.
                      /// </summary>
                      /// <returns></returns>
-                     public string GetTokenValue() {
+                     protected string GetTokenValue() {
                          return new String(m_buffer, m_tokenOffset, m_tokenLen);
                      }
                      /// <summary>
                      /// Метки текущего токена, которые были назначены в регулярном выражении.
                      /// </summary>
-                     public int[] TokenTags {
+                     protected int[] TokenTags {
                          get {
                              return m_currentState.tag;
                          }
                          return true;
                      }
-                     /// <summary>
-                     /// Вызывается по достижению конца входного буффера для получения
-                     /// новых данных.
-                     /// </summary>
-                     /// <returns><c>true</c> - новые двнные получены, можно продолжать обработку.</returns>
-                     protected virtual bool ReadNextChunk() {
+                     bool ReadNextChunk() {
+                         if (m_reader == null)
                          return false;
+                         //  extend buffer if nesessary
+                         if (m_pointer + m_chunkSize > m_buffer.Length) {
+                             // trim unused buffer head
+                             var size = m_tokenLen + m_chunkSize;
+                             if (size >= m_limit)
+                                 throw new ParserException(String.Format("Input buffer {0} bytes limit exceeded", m_limit));
+                             var temp = new char[size];
+                             Array.Copy(m_buffer, m_tokenOffset, temp, 0, m_tokenLen);
+                             m_pointer -= m_tokenOffset;
+                             m_bufferSize -= m_tokenOffset;
+                             m_tokenOffset = 0;
+                             m_buffer = temp;
+                         }
+                         var read = m_reader.Read(m_buffer, m_tokenLen, m_chunkSize);
+                         if (read == 0)
+                             return false;
+                         m_bufferSize += read;
+                         return true;
                      }
                      /// <summary>
                          m_alphabetMap = prev.alphabetMap;
                          m_previewCode = m_alphabetMap[m_buffer[m_pointer]];
                      }
+                     protected override void Dispose(bool disposing) {
+                         if (disposing) {
+                             if (m_reader != null && m_disposeReader)
+                                 m_reader.Dispose();
+                             m_buffer = null;
+                             m_bufferSize = 0;
+                             m_pointer = 0;
+                             m_tokenLen = 0;
+                             m_tokenOffset = 0;
+                         }
+                         base.Dispose(disposing);
                  }
              }
+             }

Implab/Properties/AssemblyInfo.cs +2 0

              using System.Reflection;
              using System.Runtime.CompilerServices;
+             using System.Runtime.InteropServices;
              // Information about this assembly is defined by the following attributes.
              // Change them to the values specific to your project.
              // and "{Major}.{Minor}.{Build}.*" will update just the revision.
              [assembly: AssemblyVersion("1.0.*")]
+             [assembly: ComVisible(false)]
              // The following attributes are used to specify the signing key for the assembly,
              // if desired. See the Mono documentation for more information about signing.

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages