implab/ImplabNet Commit - r179:478ef706906a

sync

cin -

r179:478ef706906a ref20160224

parent child

Context file:

r179:478ef706906a

Collapse all files

Implab/Automaton/AutomatonConst.cs +1 -1

             namespace Implab.Automaton {
-                public static class DFAConst {
+                public static class AutomatonConst {
                     public const int UNREACHABLE_STATE = -1;
                     public const int UNCLASSIFIED_INPUT = 0;
                 }
             }

Implab/Automaton/RegularExpressions/RegularDFA.cs +4 -4

             using System.Collections.Generic;
             using System.Linq;
             namespace Implab.Automaton.RegularExpressions {
-                public class TaggedDFA<TInput, TTag> : DFATable, ITaggedDFABuilder<TTag> {
+                public class RegularDFA<TInput, TTag> : DFATable, ITaggedDFABuilder<TTag> {
                     readonly Dictionary<int,TTag[]> m_tags = new Dictionary<int, TTag[]>();
                     readonly IAlphabet<TInput> m_alphabet;
-                    public TaggedDFA(IAlphabet<TInput> alphabet) {
+                    public RegularDFA(IAlphabet<TInput> alphabet) {
                         Safe.ArgumentNotNull(alphabet, "aplhabet");
                         m_alphabet = alphabet;
                     }
                     public IAlphabet<TInput> InputAlphabet {
                         get {
                             return m_alphabet;
                         }
                     }
                     public void MarkFinalState(int s, TTag[] tags) {
                         MarkFinalState(s);
                         SetStateTag(s, tags);
                     }
                     public void SetStateTag(int s, TTag[] tags) {
                         Safe.ArgumentNotNull(tags, "tags");
                         m_tags[s] = tags;
                     }
                     public TTag[] GetStateTag(int s) {
                         TTag[] tags;
                         return m_tags.TryGetValue(s, out tags) ? tags : new TTag[0];
                     }
                     public TTag[][] CreateTagTable() {
                         var table = new TTag[StateCount][];
                         foreach (var pair in m_tags)
                             table[pair.Key] = pair.Value;
                         return table;
                     }
                     /// <summary>
                     /// Optimize the specified alphabet.
                     /// </summary>
                     /// <param name="alphabet">Пустой алфавит, который будет зполнен в процессе оптимизации.</param>
-                    public TaggedDFA<TInput,TTag> Optimize(IAlphabetBuilder<TInput> alphabet) {
+                    public RegularDFA<TInput,TTag> Optimize(IAlphabetBuilder<TInput> alphabet) {
                         Safe.ArgumentNotNull(alphabet, "alphabet");
-                        var dfa = new TaggedDFA<TInput, TTag>(alphabet);
+                        var dfa = new RegularDFA<TInput, TTag>(alphabet);
                         var states = new DummyAlphabet(StateCount);
                         var alphaMap = new Dictionary<int,int>();
                         var stateMap = new Dictionary<int,int>();
                         Optimize(dfa, alphaMap, stateMap);
                         // mark tags in the new DFA
                         foreach (var g in m_tags.Where(x => x.Key < StateCount).GroupBy(x => stateMap[x.Key], x => x.Value ))
                             dfa.SetStateTag(g.Key, g.SelectMany(x => x).ToArray());
                         // make the alphabet for the new DFA
                         foreach (var pair in alphaMap)
                             alphabet.DefineClass(m_alphabet.GetSymbols(pair.Key), pair.Value);
                         return dfa;
                     }
                     protected override IEnumerable<HashSet<int>> GroupFinalStates() {
                         var arrayComparer = new CustomEqualityComparer<TTag[]>(
                             (x,y) => x.Length == y.Length && x.All(it => y.Contains(it)),
                             x => x.Sum(it => x.GetHashCode())
                         );
                         return FinalStates.GroupBy(x => m_tags[x], arrayComparer).Select(g => new HashSet<int>(g));
                     }
                 }
             }

Implab/Formats/JSON/JSONScanner.cs +2 -2

             using System;
             using System.Globalization;
             using Implab.Automaton;
             using System.Text;
             using Implab.Components;
             using System.IO;
             namespace Implab.Formats.JSON {
                 /// <summary>
                 /// Сканнер (лексер), разбивающий поток символов на токены JSON.
                 /// </summary>
                 public class JSONScanner : Disposable {
                     readonly StringBuilder m_builder = new StringBuilder();
-                    readonly ScannerContext<JSONGrammar.TokenType> m_jsonContext = JSONGrammar.Instance.JsonDFA;
+                    readonly ScannerContext<JSONGrammar.TokenType> m_jsonContext = JSONGrammar.Instance.JsonExpression;
-                    readonly ScannerContext<JSONGrammar.TokenType> m_stringContext = JSONGrammar.Instance.JsonStringDFA;
+                    readonly ScannerContext<JSONGrammar.TokenType> m_stringContext = JSONGrammar.Instance.JsonStringExpression;
                     readonly TextScanner m_scanner;
                     /// <summary>
                     /// Создает новый экземпляр сканнера
                     /// </summary>
                     public JSONScanner(string text) {
                         Safe.ArgumentNotEmpty(text, "text");
                         m_scanner = new StringScanner(text);
                     }
                     public JSONScanner(TextReader reader, int bufferMax, int chunkSize) {
                         Safe.ArgumentNotNull(reader, "reader");
                         m_scanner = new ReaderScanner(reader, bufferMax, chunkSize);
                     }
                     /// <summary>
                     /// Читает следующий лексический элемент из входных данных.
                     /// </summary>
                     /// <param name="tokenValue">Возвращает значение прочитанного токена.</param>
                     /// <param name="tokenType">Возвращает тип прочитанного токена.</param>
                     /// <returns><c>true</c> - чтение произведено успешно. <c>false</c> - достигнут конец входных данных</returns>
                     /// <remarks>В случе если токен не распознается, возникает исключение. Значения токенов обрабатываются, т.е.
                     /// в строках обрабатываются экранированные символы, числа становтся типа double.</remarks>
                     public bool ReadToken(out object tokenValue, out JsonTokenType tokenType) {
                         JSONGrammar.TokenType[] tag;
                         if (m_jsonContext.Execute(m_scanner, out tag)) {
                             switch (tag[0]) {
                                 case JSONGrammar.TokenType.StringBound:
                                     tokenValue = ReadString();
                                     tokenType = JsonTokenType.String;
                                     break;
                                 case JSONGrammar.TokenType.Number:
                                     tokenValue = Double.Parse(m_scanner.GetTokenValue(), CultureInfo.InvariantCulture);
                                     tokenType = JsonTokenType.Number;
                                     break;
                                 default:
                                     tokenType = (JsonTokenType)tag[0];
                                     tokenValue = m_scanner.GetTokenValue();
                                     break;
                             }
                             return true;
                         }
                         tokenValue = null;
                         tokenType = JsonTokenType.None;
                         return false;
                     }
                     string ReadString() {
                         int pos = 0;
                         var buf = new char[6]; // the buffer for unescaping chars
                         JSONGrammar.TokenType[] tag;
                         m_builder.Clear();
                         while (m_stringContext.Execute(m_scanner, out tag)) {
                             switch (tag[0]) {
                                 case JSONGrammar.TokenType.StringBound:
                                     return m_builder.ToString();
                                 case JSONGrammar.TokenType.UnescapedChar:
                                     m_scanner.CopyTokenTo(m_builder);
                                     break;
                                 case JSONGrammar.TokenType.EscapedUnicode: // \xXXXX - unicode escape sequence
                                     m_scanner.CopyTokenTo(buf, 0);
                                     m_builder.Append(StringTranslator.TranslateHexUnicode(buf, 2));
                                     pos++;
                                     break;
                                 case JSONGrammar.TokenType.EscapedChar:  // \t - escape sequence
                                     m_scanner.CopyTokenTo(buf, 0);
                                     m_builder.Append(StringTranslator.TranslateEscapedChar(buf[1]));
                                     break;
                             }
                         }
                         throw new ParserException("Unexpected end of data");
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing)
                             Safe.Dispose(m_scanner);
                         base.Dispose(disposing);
                     }
                 }
             }

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