implab/ImplabNet Commit - r174:983df35b3ca1

sync

cin -

r174:983df35b3ca1 ref20160224

parent child

Context file:

r174:983df35b3ca1

Collapse all files

Implab/Automaton/Scanner.cs +255 -255

This diff has been collapsed as it changes many lines, (510 lines changed) Show them Hide them
			@@ -1,255 +1,255
	1		using Implab;
	2		using System;
	3		using System.Collections.Generic;
	4		using System.IO;
	5		using Implab.Components;
	6		using Implab.Automaton.RegularExpressions;
	7
	8		namespace Implab.Automaton {
	9		/// <summary>
	10		/// Базовый класс для разбора потока входных символов на токены.
	11		/// </summary>
	12		/// <remarks>
	13		/// Сканнер имеет внутри буффер с симолами входного текста, по которому перемещаются два
	14		/// указателя, начала и конца токена, при перемещении искользуется ДКА для определения
	15		/// конца токена и допустимости текущего символа.
	16		/// </remarks>
	17		public abstract class Scanner<TTag> : Disposable {
	18		protected struct ScannerConfig {
	19		public readonly DFAStateDescriptor<TTag>[] states;
	20		public readonly int[] alphabet;
	21		public readonly int initialState;
	22
	23		public ScannerConfig(DFAStateDescriptor<TTag>[] states, int[] alphabet, int initialState) {
	24		this.initialState = initialState;
	25		this.alphabet = alphabet;
	26		this.states = states;
	27		}
	28		}
	29
	30		Stack<ScannerConfig> m_defs = new Stack<ScannerConfig>();
	31
	32		ScannerConfig m_config;
	33
	34		protected DFAStateDescriptor<TTag> m_currentState;
	35		int m_previewCode;
	36
	37		protected int m_tokenLen;
	38		protected int m_tokenOffset;
	39
	40		protected char[] m_buffer;
	41		protected int m_bufferSize;
	42		protected int m_pointer;
	43
	44		TextReader m_reader;
	45		bool m_disposeReader;
	46		int m_chunkSize = 1024; // 1k
	47		int m_limit = 10 * 1024 * 1024; // 10Mb
	48
	49		protected Scanner(ScannerConfig config) {
	50		Safe.ArgumentNotEmpty(config.states, "config.states");
	51		Safe.ArgumentNotNull(config.alphabet, "config.alphabet");
	52
	53		m_config = config;
	54		}
	55
	56		/// <summary>
	57		/// Заполняет входными данными буффер.
	58		/// </summary>
	59		/// <param name="data">Данные для обработки.</param>
	60		/// <remarks>Копирование данных не происходит, переданный массив используется в
	61		/// качестве входного буффера.</remarks>
	62		public void Feed(char[] data) {
	63		Safe.ArgumentNotNull(data, "data");
	64
	65		Feed(data, data.Length);
	66		}
	67
	68		/// <summary>
	69		/// Заполняет буффур чтения входными данными.
	70		/// </summary>
	71		/// <param name="data">Данные для обработки.</param>
	72		/// <param name="length">Длина данных для обработки.</param>
	73		/// <remarks>Копирование данных не происходит, переданный массив используется в
	74		/// качестве входного буффера.</remarks>
	75		public void Feed(char[] data, int length) {
	76		Safe.ArgumentNotNull(data, "data");
	77		Safe.ArgumentInRange(length, 0, data.Length, "length");
	78		AssertNotDisposed();
	79
	80		m_pointer = -1;
	81		m_buffer = data;
	82		m_bufferSize = length;
	83		Shift();
	84		}
	85
	86		public void Feed(TextReader reader, bool dispose) {
	87		Safe.ArgumentNotNull(reader, "reader");
	88		AssertNotDisposed();
	89
	90		if (m_reader != null && m_disposeReader)
	91		m_reader.Dispose();
	92
	93		m_reader = reader;
	94		m_disposeReader = dispose;
	95		m_pointer = -1;
	96		m_buffer = new char[m_chunkSize];
	97		m_bufferSize = 0;
	98		Shift();
	99		}
	100
	101		/// <summary>
	102		/// Получает текущий токен в виде строки.
	103		/// </summary>
	104		/// <returns></returns>
	105		protected string GetTokenValue() {
	106		return new String(m_buffer, m_tokenOffset, m_tokenLen);
	107		}
	108
	109		/// <summary>
	110		/// Метки текущего токена, которые были назначены в регулярном выражении.
	111		/// </summary>
	112		protected TTag[] TokenTags {
	113		get {
	114		return m_currentState.tags;
	115		}
	116		}
	117
	118		/// <summary>
	119		/// Признак конца данных
	120		/// </summary>
	121		public bool EOF {
	122		get {
	123		return m_pointer >= m_bufferSize;
	124		}
	125		}
	126
	127		/// <summary>
	128		/// Читает следующий токен, при этом <see cref="m_tokenOffset"/> указывает на начало токена,
	129		/// <see cref="m_tokenLen"/> на длину токена, <see cref="m_buffer"/> - массив символов, в
	130		/// котором находится токен.
	131		/// </summary>
	132		/// <returns><c>false</c> - достигнут конец данных, токен не прочитан.</returns>
	133		protected bool ReadTokenInternal() {
	134		if (m_pointer >= m_bufferSize)
	135		return false;
	136
	137		m_currentState = m_config.states[m_config.initialState];
	138		m_tokenLen = 0;
	139		m_tokenOffset = m_pointer;
	140		int nextState;
	141		do {
	142		nextState = m_currentState.transitions[m_previewCode];
	143		if (nextState == DFAConst.UNREACHABLE_STATE) {
	144		if (m_currentState.final)
	145		return true;
	146
	147		throw new ParserException(
	148		String.Format(
	149		"Unexpected symbol '{0}', at pos {1}",
	150		m_buffer[m_pointer],
	151		Position
	152		)
	153		);
	154		}
	155		m_currentState = m_config.states[nextState];
	156		m_tokenLen++;
	157
	158		} while (Shift());
	159
	160		// END OF DATA
	161		if (!m_currentState.final)
	162		throw new ParserException("Unexpected end of data");
	163
	164		return true;
	165		}
	166
	167
	168		bool Shift() {
	169		m_pointer++;
	170
	171		if (m_pointer >= m_bufferSize) {
	172		if (!ReadNextChunk())
	173		return false;
	174		}
	175
	176		m_previewCode = m_config.alphabet[m_buffer[m_pointer]];
	177
	178		return true;
	179		}
	180
	181		bool ReadNextChunk() {
	182		if (m_reader == null)
	183		return false;
	184
	185		// extend buffer if nesessary
	186		if (m_pointer + m_chunkSize > m_buffer.Length) {
	187		// trim unused buffer head
	188		var size = m_tokenLen + m_chunkSize;
	189		if (size >= m_limit)
	190		throw new ParserException(String.Format("Input buffer {0} bytes limit exceeded", m_limit));
	191		var temp = new char[size];
	192		Array.Copy(m_buffer, m_tokenOffset, temp, 0, m_tokenLen);
	193		m_pointer -= m_tokenOffset;
	194		m_bufferSize -= m_tokenOffset;
	195		m_tokenOffset = 0;
	196		m_buffer = temp;
	197		}
	198
	199		var read = m_reader.Read(m_buffer, m_tokenLen, m_chunkSize);
	200		if (read == 0)
	201		return false;
	202
	203		m_bufferSize += read;
	204
	205		return true;
	206		}
	207
	208		/// <summary>
	209		/// Позиция сканнера во входном буфере
	210		/// </summary>
	211		public int Position {
	212		get {
	213		return m_pointer + 1;
	214		}
	215		}
	216
	217		/// <summary>
	218		/// Преключает внутренний ДКА на указанный, позволяет реализовать подобие захватывающей
	219		/// группировки.
	220		/// </summary>
	221		/// <param name = "config"></param>
	222		protected void Switch(ScannerConfig config) {
	223		Safe.ArgumentNotNull(config.states, "config.states");
	224
	225		m_defs.Push(m_config);
	226		m_config = config;
	227
	228		m_previewCode = m_config.alphabet[m_buffer[m_pointer]];
	229		}
	230
	231		/// <summary>
	232		/// Восстанавливает предыдущей ДКА сканнера.
	233		/// </summary>
	234		protected void Restore() {
	235		if (m_defs.Count == 0)
	236		throw new InvalidOperationException();
	237		m_config = m_defs.Pop();
	238
	239		m_previewCode = m_config.alphabet[m_buffer[m_pointer]];
	240		}
	241
	242		protected override void Dispose(bool disposing) {
	243		if (disposing) {
	244		if (m_reader != null && m_disposeReader)
	245		m_reader.Dispose();
	246		m_buffer = null;
	247		m_bufferSize = 0;
	248		m_pointer = 0;
	249		m_tokenLen = 0;
	250		m_tokenOffset = 0;
	251		}
	252		base.Dispose(disposing);
	253		}
	254		}
	255		}
		1	using Implab;
		2	using System;
		3	using System.Collections.Generic;
		4	using System.IO;
		5	using Implab.Components;
		6	using Implab.Automaton.RegularExpressions;
		7
		8	namespace Implab.Automaton {
		9	/// <summary>
		10	/// Базовый класс для разбора потока входных символов на токены.
		11	/// </summary>
		12	/// <remarks>
		13	/// Сканнер имеет внутри буффер с симолами входного текста, по которому перемещаются два
		14	/// указателя, начала и конца токена, при перемещении искользуется ДКА для определения
		15	/// конца токена и допустимости текущего символа.
		16	/// </remarks>
		17	public abstract class Scanner<TTag> : Disposable {
		18	protected struct ScannerConfig {
		19	public readonly DFAStateDescriptor<TTag>[] states;
		20	public readonly int[] alphabet;
		21	public readonly int initialState;
		22
		23	public ScannerConfig(DFAStateDescriptor<TTag>[] states, int[] alphabet, int initialState) {
		24	this.initialState = initialState;
		25	this.alphabet = alphabet;
		26	this.states = states;
		27	}
		28	}
		29
		30	Stack<ScannerConfig> m_defs = new Stack<ScannerConfig>();
		31
		32	ScannerConfig m_config;
		33
		34	protected DFAStateDescriptor<TTag> m_currentState;
		35	int m_previewCode;
		36
		37	protected int m_tokenLen;
		38	protected int m_tokenOffset;
		39
		40	protected char[] m_buffer;
		41	protected int m_bufferSize;
		42	protected int m_pointer;
		43
		44	TextReader m_reader;
		45	bool m_disposeReader;
		46	int m_chunkSize = 1024; // 1k
		47	int m_limit = 10 * 1024 * 1024; // 10Mb
		48
		49	protected Scanner(ScannerConfig config) {
		50	Safe.ArgumentNotEmpty(config.states, "config.states");
		51	Safe.ArgumentNotNull(config.alphabet, "config.alphabet");
		52
		53	m_config = config;
		54	}
		55
		56	/// <summary>
		57	/// Заполняет входными данными буффер.
		58	/// </summary>
		59	/// <param name="data">Данные для обработки.</param>
		60	/// <remarks>Копирование данных не происходит, переданный массив используется в
		61	/// качестве входного буффера.</remarks>
		62	public void Feed(char[] data) {
		63	Safe.ArgumentNotNull(data, "data");
		64
		65	Feed(data, data.Length);
		66	}
		67
		68	/// <summary>
		69	/// Заполняет буффур чтения входными данными.
		70	/// </summary>
		71	/// <param name="data">Данные для обработки.</param>
		72	/// <param name="length">Длина данных для обработки.</param>
		73	/// <remarks>Копирование данных не происходит, переданный массив используется в
		74	/// качестве входного буффера.</remarks>
		75	public void Feed(char[] data, int length) {
		76	Safe.ArgumentNotNull(data, "data");
		77	Safe.ArgumentInRange(length, 0, data.Length, "length");
		78	AssertNotDisposed();
		79
		80	m_pointer = -1;
		81	m_buffer = data;
		82	m_bufferSize = length;
		83	Shift();
		84	}
		85
		86	public void Feed(TextReader reader, bool dispose) {
		87	Safe.ArgumentNotNull(reader, "reader");
		88	AssertNotDisposed();
		89
		90	if (m_reader != null && m_disposeReader)
		91	m_reader.Dispose();
		92
		93	m_reader = reader;
		94	m_disposeReader = dispose;
		95	m_pointer = -1;
		96	m_buffer = new char[m_chunkSize];
		97	m_bufferSize = 0;
		98	Shift();
		99	}
		100
		101	/// <summary>
		102	/// Получает текущий токен в виде строки.
		103	/// </summary>
		104	/// <returns></returns>
		105	protected string GetTokenValue() {
		106	return new String(m_buffer, m_tokenOffset, m_tokenLen);
		107	}
		108
		109	/// <summary>
		110	/// Метки текущего токена, которые были назначены в регулярном выражении.
		111	/// </summary>
		112	protected TTag[] TokenTags {
		113	get {
		114	return m_currentState.tags;
		115	}
		116	}
		117
		118	/// <summary>
		119	/// Признак конца данных
		120	/// </summary>
		121	public bool EOF {
		122	get {
		123	return m_pointer >= m_bufferSize;
		124	}
		125	}
		126
		127	/// <summary>
		128	/// Читает следующий токен, при этом <see cref="m_tokenOffset"/> указывает на начало токена,
		129	/// <see cref="m_tokenLen"/> на длину токена, <see cref="m_buffer"/> - массив символов, в
		130	/// котором находится токен.
		131	/// </summary>
		132	/// <returns><c>false</c> - достигнут конец данных, токен не прочитан.</returns>
		133	protected bool ReadTokenInternal() {
		134	if (m_pointer >= m_bufferSize)
		135	return false;
		136
		137	m_currentState = m_config.states[m_config.initialState];
		138	m_tokenLen = 0;
		139	m_tokenOffset = m_pointer;
		140	int nextState;
		141	do {
		142	nextState = m_currentState.transitions[m_previewCode];
		143	if (nextState == DFAConst.UNREACHABLE_STATE) {
		144	if (m_currentState.final)
		145	return true;
		146
		147	throw new ParserException(
		148	String.Format(
		149	"Unexpected symbol '{0}', at pos {1}",
		150	m_buffer[m_pointer],
		151	Position
		152	)
		153	);
		154	}
		155	m_currentState = m_config.states[nextState];
		156	m_tokenLen++;
		157
		158	} while (Shift());
		159
		160	// END OF DATA
		161	if (!m_currentState.final)
		162	throw new ParserException("Unexpected end of data");
		163
		164	return true;
		165	}
		166
		167
		168	bool Shift() {
		169	m_pointer++;
		170
		171	if (m_pointer >= m_bufferSize) {
		172	if (!ReadNextChunk())
		173	return false;
		174	}
		175
		176	m_previewCode = m_config.alphabet[m_buffer[m_pointer]];
		177
		178	return true;
		179	}
		180
		181	bool ReadNextChunk() {
		182	if (m_reader == null)
		183	return false;
		184
		185	// extend buffer if nesessary
		186	if (m_pointer + m_chunkSize > m_buffer.Length) {
		187	// trim unused buffer head
		188	var size = m_tokenLen + m_chunkSize;
		189	if (size >= m_limit)
		190	throw new ParserException(String.Format("Input buffer {0} bytes limit exceeded", m_limit));
		191	var temp = new char[size];
		192	Array.Copy(m_buffer, m_tokenOffset, temp, 0, m_tokenLen);
		193	m_pointer -= m_tokenOffset;
		194	m_bufferSize -= m_tokenOffset;
		195	m_tokenOffset = 0;
		196	m_buffer = temp;
		197	}
		198
		199	var read = m_reader.Read(m_buffer, m_tokenLen, m_chunkSize);
		200	if (read == 0)
		201	return false;
		202
		203	m_bufferSize += read;
		204
		205	return true;
		206	}
		207
		208	/// <summary>
		209	/// Позиция сканнера во входном буфере
		210	/// </summary>
		211	public int Position {
		212	get {
		213	return m_pointer + 1;
		214	}
		215	}
		216
		217	/// <summary>
		218	/// Преключает внутренний ДКА на указанный, позволяет реализовать подобие захватывающей
		219	/// группировки.
		220	/// </summary>
		221	/// <param name = "config"></param>
		222	protected void Switch(ScannerConfig config) {
		223	Safe.ArgumentNotNull(config.states, "config.states");
		224
		225	m_defs.Push(m_config);
		226	m_config = config;
		227
		228	m_previewCode = m_config.alphabet[m_buffer[m_pointer]];
		229	}
		230
		231	/// <summary>
		232	/// Восстанавливает предыдущей ДКА сканнера.
		233	/// </summary>
		234	protected void Restore() {
		235	if (m_defs.Count == 0)
		236	throw new InvalidOperationException();
		237	m_config = m_defs.Pop();
		238
		239	m_previewCode = m_config.alphabet[m_buffer[m_pointer]];
		240	}
		241
		242	protected override void Dispose(bool disposing) {
		243	if (disposing) {
		244	if (m_reader != null && m_disposeReader)
		245	m_reader.Dispose();
		246	m_buffer = null;
		247	m_bufferSize = 0;
		248	m_pointer = 0;
		249	m_tokenLen = 0;
		250	m_tokenOffset = 0;
		251	}
		252	base.Dispose(disposing);
		253	}
		254	}
		255	}

Implab/Formats/BufferScanner.cs +13 -94

              using System;
              using Implab.Automaton.RegularExpressions;
              using Implab.Automaton;
+             using System.Diagnostics;
              namespace Implab.Formats {
                  public struct BufferScanner<TTag> {
-                     char[] m_buffer;
-                     int m_offset;
-                     int m_position;
-                     int m_hi;
-                     readonly int m_chunk;
-                     readonly int m_limit;
                      readonly DFAStateDescriptor<TTag>[] m_dfa;
                      int m_state;
+                     int m_pos;
-                     public BufferScanner(DFAStateDescriptor<TTag>[] dfa, int initialState, int chunk, int limit) {
+                     public BufferScanner(DFAStateDescriptor<TTag>[] dfa, int initialState) {
                          m_dfa = dfa;
                          m_state = initialState;
-                         m_chunk = chunk;
-                         m_limit = limit;
-                         m_buffer = null;
-                         m_offset = 0;
-                         m_position = 0;
-                         m_hi = 0;
+                     }
-                     public char[] Buffer {
-                         get {
-                             return m_buffer;
+                         }
+                     }
-                     public int HiMark {
-                         get {
-                             return m_hi;
+                         }
                      }
                      public int Position {
-                         get {
-                             return m_position;
+                         }
+                     }
-                     public int Length {
-                         get {
-                             return m_hi - m_position;
+                         }
+                     }
-                     public int TokenOffset {
-                         get {
-                             return m_offset;
+                         }
+                     }
-                     public int TokenLength {
-                         get {
-                             return m_position - m_offset;
+                         }
+                     }
-                     public void Init(char[] buffer, int position, int length) {
-                         m_buffer = buffer;
-                         m_position = position;
-                         m_offset = position;
-                         m_hi = position + length;
+                     }
-                     public int Extend() {
-                         // free space
-                         var free = m_buffer.Length - m_hi;
-                         // if the buffer have enough free space
-                         if (free > 0)
-                             return free;
-                         // effective size of the buffer
-                         var size = m_buffer.Length - m_offset;
-                         // calculate the new size
-                         int grow = Math.Min(m_limit - size, m_chunk);
-                         if (grow <= 0)
-                             throw new ParserException(String.Format("Input buffer {0} bytes limit exceeded", m_limit));
-                         var temp = new char[size + grow];
-                         Array.Copy(m_buffer, m_offset, temp, 0, m_hi - m_offset);
-                         m_position -= m_offset;
-                         m_hi -= m_offset;
-                         m_offset = 0;
-                         m_buffer = temp;
-                         return free + grow;
+                     }
-                     public void RaiseMark(int size) {
-                         m_hi += size;
+                         get { return m_pos; }
                      }
                      /// <summary>
                      /// Scan this instance.
                      /// </summary>
                      /// <returns><c>true</c> - additional data required</returns>
-                     public bool Scan() {
-                         while (m_position < m_hi) {
-                             var ch = m_buffer[m_position];
-                             var next = m_dfa[m_state].transitions[(int)ch];
+                     public bool Scan(int[] buffer, int position, int length) {
+                         var hi = position + length;
+                         m_pos = position;
+                         while (position < hi) {
+                             var next = m_dfa[m_state].transitions[buffer[position]];
                              if (next == DFAConst.UNREACHABLE_STATE) {
                                  if (m_dfa[m_state].final)
                                      return false;
                                  throw new ParserException(
                                      String.Format(
-                                         "Unexpected token '{0}'",
-                                         new string(m_buffer, m_offset, m_position - m_offset)
+                                         "Unexpected symbol"
                                      )
                                  );
                              }
+                             m_pos++;
                              m_state = next;
-                             m_position++;
                          }
                          return true;
                      }
                      public void Eof() {
                          if (!m_dfa[m_state].final)
                              throw new ParserException(
                                  String.Format(
-                                     "Unexpected token '{0}'",
-                                     new string(m_buffer, m_offset, m_position - m_offset)
+                                     "Unexpected EOF"
                                  )
                              );
                      }
                      public TTag[] GetTokenTags() {
                          return m_dfa[m_state].tags;
                      }
                  }
              }

Implab/Formats/TextScanner.cs +27 -38

              using System;
              using Implab.Components;
              namespace Implab.Formats {
                  public abstract class TextScanner<TTag> : Disposable {
-                     char[] m_buffer;
-                     int m_offset;
-                     int m_length;
-                     int m_tokenOffset;
+                     readonly int[] m_buffer;
+                     int m_bufferOffset;
+                     int m_dataLength;
                      int m_tokenLength;
                      TTag[] m_tags;
                      BufferScanner<TTag> m_scanner;
                      protected bool ReadTokenInternal() {
                          if (EOF)
                              return false;
-                         // create a new scanner from template (scanners are structs)
+                         // create a new scanner from template (scanners are value types)
                          var inst = m_scanner;
-                         // initialize the scanner
-                         inst.Init(m_buffer, m_offset, m_length);
+                         m_tokenLength = 0;
+                         while (inst.Scan(m_buffer, m_bufferOffset, m_dataLength)) {
+                             m_tokenLength += m_dataLength;
+                             var actual = Read(m_buffer, 0, m_buffer.Length);
+                             m_bufferOffset = 0;
+                             m_dataLength = actual;
-                         // do work
-                         while (inst.Scan())
-                             Feed(ref inst);
+                             if (actual == 0) {
+                                 inst.Eof();
+                                 break;
+                             }
+                         }
+                         var len = inst.Position - m_bufferOffset;
+                         m_tokenLength += len;
+                         m_dataLength -= len;
+                         m_bufferOffset = inst.Position;
                          // save result;
-                         m_buffer = inst.Buffer;
-                         m_length = inst.Length;
-                         m_offset = inst.Position;
-                         m_tokenOffset = inst.TokenOffset;
-                         m_tokenLength = inst.TokenLength;
                          m_tags = inst.GetTokenTags();
                      }
-                     protected string GetToken() {
-                         return new String(m_buffer, m_tokenOffset, m_tokenLength);
+                     }
+                     protected abstract int Read(int[] buffer, int offset, int size);
                      protected TTag[] Tags {
                          get {
                              return m_tags;
                          }
                      }
-                     /// <summary>
-                     /// Feed the specified scanner.
-                     /// </summary>
-                     /// <param name="scanner">Scanner.</param>
-                     /// <example>
-                     /// protected override void Feed(ref BufferScanner<TTag> scanner) {
-                     ///     var size = scanner.Extend();
-                     ///     var actual = m_reader.Read(scanner.Buffer, scanner.HiMark, size);
-                     ///     if (actual == 0) {
-                     ///         m_eof = true;
-                     ///         scanner.Eof();
-                     ///     } else {
-                     ///         scanner.RaiseHiMark(actual);
-                     ///     }
-                     /// }
-                     /// </example>
-                     protected abstract void Feed(ref BufferScanner<TTag> scanner);
                      public abstract bool EOF { get; }
                  }
              }

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