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 +57 -5

             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,
                         MemberValue
+                    }
                     static readonly EnumAlphabet<JsonTokenType> _alphabet = EnumAlphabet<JsonTokenType>.FullAlphabet;
                     static readonly DFAStateDescriptior[] _jsonDFA;
                     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 } ) {
+                        : base(_jsonDFA, INITIAL_STATE, new JSONParserContext { elementContext = JSONElementContext.None, memberName = String.Empty }) {
                         Safe.ArgumentNotEmpty(text, "text");
                         m_scanner = new JSONScanner();
                         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");
                                     Switch(
                                         _objectDFA,
                                         INITIAL_STATE,
                                         new JSONParserContext {
                                             memberName = m_context.info.memberName,
                                             elementContext = JSONElementContext.Object
                                         }
                         switch (literal) {
                             case "null":
                                 return null;
-                            case "false" :
+                            case "false":
                                 return false;
                             case "true":
                                 return true;
                     }
+                    /// <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 +9 -1

@@ -272,7 +272,15 namespace ConsPlay {
272	}	272	}
273		273
274	public override void Close() {	274	public override void Close() {
275	m_state = System.Xml.ReadState.EndOfFile ;	275
276	}	276	}
		277
		278	protected override void Dispose(bool disposing) {
		279	if (disposing) {
		280	m_parser.Dispose();
		281	}
		282	base.Dispose(disposing);
		283	}
		284
277	}	285	}
278	}	286	}

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() {
+                    protected AlphabetBase(int mapSize) {
-                        m_map = new 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 +62 -19

             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) {
+                    TextReader m_reader;
-                        Safe.ArgumentNotNull(definition, "definition");
+                    bool m_disposeReader;
-                        Safe.ArgumentNotEmpty(text, "text");
+                    int m_chunkSize = 1024; // 1k
+                    int m_limit = 10 * 1024 * 1024; // 10Mb
-                        m_states = definition.States;
-                        m_alphabetMap = definition.Alphabet.GetTranslationMap();
-                        Feed(text.ToCharArray());
                     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>
+                    bool ReadNextChunk() {
-                    /// Вызывается по достижению конца входного буффера для получения
+                        if (m_reader == null)
-                    /// новых данных.
+                            return false;
-                    /// </summary>
-                    /// <returns><c>true</c> - новые двнные получены, можно продолжать обработку.</returns>
+                        //  extend buffer if nesessary
-                    protected virtual bool ReadNextChunk() {
+                        if (m_pointer + m_chunkSize > m_buffer.Length) {
-                        return false;
+                            // 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 +3 -1

             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