668 lines
22 KiB
C#
668 lines
22 KiB
C#
// ==============================================================
|
|
// <auto-generated>
|
|
// This code automatically produced from an embedded resource.
|
|
// Do not edit this file, or it will become incompatible with
|
|
// the specification from which it was generated.
|
|
// </auto-generated>
|
|
// ==============================================================
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Runtime.Serialization;
|
|
using System.Globalization;
|
|
|
|
namespace QUT.GplexBuffers
|
|
{
|
|
// Code copied from GPLEX embedded resource
|
|
[Serializable]
|
|
internal class BufferException : Exception
|
|
{
|
|
public BufferException() { }
|
|
public BufferException(string message) : base(message) { }
|
|
public BufferException(string message, Exception innerException)
|
|
: base(message, innerException) { }
|
|
}
|
|
|
|
internal abstract class ScanBuff
|
|
{
|
|
private string fileNm;
|
|
|
|
public const int EndOfFile = -1;
|
|
public const int UnicodeReplacementChar = 0xFFFD;
|
|
|
|
public bool IsFile { get { return (fileNm != null); } }
|
|
public string FileName { get { return fileNm; } set { fileNm = value; } }
|
|
|
|
public abstract int Pos { get; set; }
|
|
public abstract int Read();
|
|
public virtual void Mark() { }
|
|
|
|
public abstract string GetString(int begin, int limit);
|
|
|
|
public static ScanBuff GetBuffer(string source)
|
|
{
|
|
return new StringBuffer(source);
|
|
}
|
|
|
|
public static ScanBuff GetBuffer(IList<string> source)
|
|
{
|
|
return new LineBuffer(source);
|
|
}
|
|
|
|
#if (!NOFILES)
|
|
public static ScanBuff GetBuffer(Stream source)
|
|
{
|
|
return new BuildBuffer(source);
|
|
}
|
|
|
|
public static ScanBuff GetBuffer(Stream source, int fallbackCodePage)
|
|
{
|
|
return new BuildBuffer(source, fallbackCodePage);
|
|
}
|
|
#endif // !NOFILES
|
|
}
|
|
|
|
#region Buffer classes
|
|
|
|
// ==============================================================
|
|
// ===== Definitions for various ScanBuff derived classes ====
|
|
// ==============================================================
|
|
// =============== String input ================
|
|
// ==============================================================
|
|
|
|
/// <summary>
|
|
/// This class reads characters from a single string as
|
|
/// required, for example, by Visual Studio language services
|
|
/// </summary>
|
|
sealed class StringBuffer : ScanBuff
|
|
{
|
|
string str; // input buffer
|
|
int bPos; // current position in buffer
|
|
int sLen;
|
|
|
|
public StringBuffer(string source)
|
|
{
|
|
this.str = source;
|
|
this.sLen = source.Length;
|
|
this.FileName = null;
|
|
}
|
|
|
|
public override int Read()
|
|
{
|
|
if (bPos < sLen) return str[bPos++];
|
|
else if (bPos == sLen) { bPos++; return '\n'; } // one strike, see new line
|
|
else { bPos++; return EndOfFile; } // two strikes and you're out!
|
|
}
|
|
|
|
public override string GetString(int begin, int limit)
|
|
{
|
|
// "limit" can be greater than sLen with the BABEL
|
|
// option set. Read returns a "virtual" EOL if
|
|
// an attempt is made to read past the end of the
|
|
// string buffer. Without the guard any attempt
|
|
// to fetch yytext for a token that includes the
|
|
// EOL will throw an index exception.
|
|
if (limit > sLen) limit = sLen;
|
|
if (limit <= begin) return "";
|
|
else return str.Substring(begin, limit - begin);
|
|
}
|
|
|
|
public override int Pos
|
|
{
|
|
get { return bPos; }
|
|
set { bPos = value; }
|
|
}
|
|
|
|
public override string ToString() { return "StringBuffer"; }
|
|
}
|
|
|
|
// ==============================================================
|
|
// The LineBuff class contributed by Nigel Horspool,
|
|
// nigelh@cs.uvic.cs
|
|
// ==============================================================
|
|
|
|
sealed class LineBuffer : ScanBuff
|
|
{
|
|
IList<string> line; // list of source lines from a file
|
|
int numLines; // number of strings in line list
|
|
string curLine; // current line in that list
|
|
int cLine; // index of current line in the list
|
|
int curLen; // length of current line
|
|
int curLineStart; // position of line start in whole file
|
|
int curLineEnd; // position of line end in whole file
|
|
int maxPos; // max position ever visited in whole file
|
|
int cPos; // ordinal number of code in source
|
|
|
|
// Constructed from a list of strings, one per source line.
|
|
// The lines have had trailing '\n' characters removed.
|
|
public LineBuffer(IList<string> lineList)
|
|
{
|
|
line = lineList;
|
|
numLines = line.Count;
|
|
cPos = curLineStart = 0;
|
|
curLine = (numLines > 0 ? line[0] : "");
|
|
maxPos = curLineEnd = curLen = curLine.Length;
|
|
cLine = 1;
|
|
FileName = null;
|
|
}
|
|
|
|
public override int Read()
|
|
{
|
|
if (cPos < curLineEnd)
|
|
return curLine[cPos++ - curLineStart];
|
|
if (cPos++ == curLineEnd)
|
|
return '\n';
|
|
if (cLine >= numLines)
|
|
return EndOfFile;
|
|
curLine = line[cLine];
|
|
curLen = curLine.Length;
|
|
curLineStart = curLineEnd + 1;
|
|
curLineEnd = curLineStart + curLen;
|
|
if (curLineEnd > maxPos)
|
|
maxPos = curLineEnd;
|
|
cLine++;
|
|
return curLen > 0 ? curLine[0] : '\n';
|
|
}
|
|
|
|
// To speed up searches for the line containing a position
|
|
private int cachedPosition;
|
|
private int cachedIxdex;
|
|
private int cachedLineStart;
|
|
|
|
// Given a position pos within the entire source, the results are
|
|
// ix -- the index of the containing line
|
|
// lstart -- the position of the first character on that line
|
|
private void findIndex(int pos, out int ix, out int lstart)
|
|
{
|
|
if (pos >= cachedPosition)
|
|
{
|
|
ix = cachedIxdex; lstart = cachedLineStart;
|
|
}
|
|
else
|
|
{
|
|
ix = lstart = 0;
|
|
}
|
|
while (ix < numLines)
|
|
{
|
|
int len = line[ix].Length + 1;
|
|
if (pos < lstart + len) break;
|
|
lstart += len;
|
|
ix++;
|
|
}
|
|
cachedPosition = pos;
|
|
cachedIxdex = ix;
|
|
cachedLineStart = lstart;
|
|
}
|
|
|
|
public override string GetString(int begin, int limit)
|
|
{
|
|
if (begin >= maxPos || limit <= begin) return "";
|
|
int endIx, begIx, endLineStart, begLineStart;
|
|
findIndex(begin, out begIx, out begLineStart);
|
|
int begCol = begin - begLineStart;
|
|
findIndex(limit, out endIx, out endLineStart);
|
|
int endCol = limit - endLineStart;
|
|
string s = line[begIx];
|
|
if (begIx == endIx)
|
|
{
|
|
// the usual case, substring all on one line
|
|
return (endCol <= s.Length) ?
|
|
s.Substring(begCol, endCol - begCol)
|
|
: s.Substring(begCol) + "\n";
|
|
}
|
|
// the string spans multiple lines, yuk!
|
|
StringBuilder sb = new StringBuilder();
|
|
if (begCol < s.Length)
|
|
sb.Append(s.Substring(begCol));
|
|
for (; ; )
|
|
{
|
|
sb.Append("\n");
|
|
s = line[++begIx];
|
|
if (begIx >= endIx) break;
|
|
sb.Append(s);
|
|
}
|
|
if (endCol <= s.Length)
|
|
{
|
|
sb.Append(s.Substring(0, endCol));
|
|
}
|
|
else
|
|
{
|
|
sb.Append(s);
|
|
sb.Append("\n");
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
public override int Pos
|
|
{
|
|
get { return cPos; }
|
|
set
|
|
{
|
|
cPos = value;
|
|
findIndex(cPos, out cLine, out curLineStart);
|
|
// cLine should be the *next* line after curLine.
|
|
curLine = (cLine < numLines ? line[cLine++] : "");
|
|
curLineEnd = curLineStart + curLine.Length;
|
|
}
|
|
}
|
|
|
|
public override string ToString() { return "LineBuffer"; }
|
|
}
|
|
|
|
#if (!NOFILES)
|
|
// ==============================================================
|
|
// ===== class BuildBuff : for unicode text files ========
|
|
// ==============================================================
|
|
|
|
class BuildBuffer : ScanBuff
|
|
{
|
|
// Double buffer for char stream.
|
|
class BufferElement
|
|
{
|
|
StringBuilder bldr = new StringBuilder();
|
|
StringBuilder next = new StringBuilder();
|
|
int minIx;
|
|
int maxIx;
|
|
int brkIx;
|
|
bool appendToNext;
|
|
|
|
internal BufferElement() { }
|
|
|
|
internal int MaxIndex { get { return maxIx; } }
|
|
// internal int MinIndex { get { return minIx; } }
|
|
|
|
internal char this[int index]
|
|
{
|
|
get
|
|
{
|
|
if (index < minIx || index >= maxIx)
|
|
throw new BufferException("Index was outside data buffer");
|
|
else if (index < brkIx)
|
|
return bldr[index - minIx];
|
|
else
|
|
return next[index - brkIx];
|
|
}
|
|
}
|
|
|
|
internal void Append(char[] block, int count)
|
|
{
|
|
maxIx += count;
|
|
if (appendToNext)
|
|
this.next.Append(block, 0, count);
|
|
else
|
|
{
|
|
this.bldr.Append(block, 0, count);
|
|
brkIx = maxIx;
|
|
appendToNext = true;
|
|
}
|
|
}
|
|
|
|
internal string GetString(int start, int limit)
|
|
{
|
|
if (limit <= start)
|
|
return "";
|
|
if (start >= minIx && limit <= maxIx)
|
|
if (limit < brkIx) // String entirely in bldr builder
|
|
return bldr.ToString(start - minIx, limit - start);
|
|
else if (start >= brkIx) // String entirely in next builder
|
|
return next.ToString(start - brkIx, limit - start);
|
|
else // Must do a string-concatenation
|
|
return
|
|
bldr.ToString(start - minIx, brkIx - start) +
|
|
next.ToString(0, limit - brkIx);
|
|
else
|
|
throw new BufferException("String was outside data buffer");
|
|
}
|
|
|
|
internal void Mark(int limit)
|
|
{
|
|
if (limit > brkIx + 16) // Rotate blocks
|
|
{
|
|
StringBuilder temp = bldr;
|
|
bldr = next;
|
|
next = temp;
|
|
next.Length = 0;
|
|
minIx = brkIx;
|
|
brkIx = maxIx;
|
|
}
|
|
}
|
|
}
|
|
|
|
BufferElement data = new BufferElement();
|
|
|
|
int bPos; // Postion index in the StringBuilder
|
|
BlockReader NextBlk; // Delegate that serves char-arrays;
|
|
|
|
private string EncodingName
|
|
{
|
|
get
|
|
{
|
|
StreamReader rdr = NextBlk.Target as StreamReader;
|
|
return (rdr == null ? "raw-bytes" : rdr.CurrentEncoding.BodyName);
|
|
}
|
|
}
|
|
|
|
public BuildBuffer(Stream stream)
|
|
{
|
|
FileStream fStrm = (stream as FileStream);
|
|
if (fStrm != null) FileName = fStrm.Name;
|
|
NextBlk = BlockReaderFactory.Get(stream);
|
|
}
|
|
|
|
public BuildBuffer(Stream stream, int fallbackCodePage)
|
|
{
|
|
FileStream fStrm = (stream as FileStream);
|
|
if (fStrm != null) FileName = fStrm.Name;
|
|
NextBlk = BlockReaderFactory.Get(stream, fallbackCodePage);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Marks a conservative lower bound for the buffer,
|
|
/// allowing space to be reclaimed. If an application
|
|
/// needs to call GetString at arbitrary past locations
|
|
/// in the input stream, Mark() is not called.
|
|
/// </summary>
|
|
public override void Mark() { data.Mark(bPos - 2); }
|
|
|
|
public override int Pos
|
|
{
|
|
get { return bPos; }
|
|
set { bPos = value; }
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Read returns the ordinal number of the next char, or
|
|
/// EOF (-1) for an end of stream. Note that the next
|
|
/// code point may require *two* calls of Read().
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override int Read()
|
|
{
|
|
//
|
|
// Characters at positions
|
|
// [data.offset, data.offset + data.bldr.Length)
|
|
// are available in data.bldr.
|
|
//
|
|
if (bPos < data.MaxIndex)
|
|
{
|
|
// ch0 cannot be EOF
|
|
return (int)data[bPos++];
|
|
}
|
|
else // Read from underlying stream
|
|
{
|
|
// Experimental code, blocks of page size
|
|
char[] chrs = new char[4096];
|
|
int count = NextBlk(chrs, 0, 4096);
|
|
if (count == 0)
|
|
return EndOfFile;
|
|
else
|
|
{
|
|
data.Append(chrs, count);
|
|
return (int)data[bPos++];
|
|
}
|
|
}
|
|
}
|
|
|
|
public override string GetString(int begin, int limit)
|
|
{
|
|
return data.GetString(begin, limit);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return "StringBuilder buffer, encoding: " + this.EncodingName;
|
|
}
|
|
}
|
|
|
|
// =============== End ScanBuff-derived classes ==================
|
|
|
|
internal delegate int BlockReader(char[] block, int index, int number);
|
|
|
|
// A delegate factory, serving up a delegate that
|
|
// reads a block of characters from the underlying
|
|
// encoded stream, via a StreamReader object.
|
|
//
|
|
internal static class BlockReaderFactory
|
|
{
|
|
|
|
public static BlockReader Get(Stream stream, int fallbackCodePage = -2)
|
|
{
|
|
Encoding encoding;
|
|
int preamble = Preamble(stream);
|
|
|
|
if (preamble != 0) // There is a valid BOM here!
|
|
encoding = Encoding.GetEncoding(preamble);
|
|
else if (fallbackCodePage >= 0) // Anything but "guess"
|
|
encoding = Encoding.GetEncoding(fallbackCodePage);
|
|
else // This is the "guess" option
|
|
encoding = GuessEncoding(stream);
|
|
|
|
StreamReader reader = new StreamReader(stream, encoding);
|
|
return reader.Read;
|
|
}
|
|
|
|
static int Preamble(Stream stream)
|
|
{
|
|
int b0 = stream.ReadByte();
|
|
int b1 = stream.ReadByte();
|
|
|
|
if (b0 == 0xfe && b1 == 0xff)
|
|
return 1201; // UTF16BE
|
|
if (b0 == 0xff && b1 == 0xfe)
|
|
return 1200; // UTF16LE
|
|
|
|
int b2 = stream.ReadByte();
|
|
if (b0 == 0xef && b1 == 0xbb && b2 == 0xbf)
|
|
return 65001; // UTF8
|
|
|
|
int b3 = stream.ReadByte();
|
|
// Check for UTF-32 BOM (Byte Order Mark)
|
|
if (b0 == 0x00 && b1 == 0x00 && b2 == 0xFE && b3 == 0xFF)
|
|
return 12001; // UTF-32BE
|
|
if (b0 == 0xFF && b1 == 0xFE && b2 == 0x00 && b3 == 0x00)
|
|
return 12000; // UTF-32LE
|
|
|
|
//
|
|
// There is no unicode preamble, so we
|
|
// return denoter for the machine default.
|
|
//
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
return 0;
|
|
}
|
|
|
|
private static Encoding GuessEncoding(Stream stream)
|
|
{
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
if (IsUtf16(stream, out Encoding encoding))
|
|
{
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
return encoding;
|
|
}
|
|
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
if (IsUtf8(stream))
|
|
{
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
return Encoding.UTF8;
|
|
}
|
|
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
if (IsAscii(stream))
|
|
{
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
return Encoding.ASCII;
|
|
}
|
|
|
|
#if !NET462_OR_GREATER
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
if (IsLatin1(stream))
|
|
{
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
return Encoding.Latin1;
|
|
}
|
|
#endif
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
return Encoding.Default;
|
|
}
|
|
|
|
private static bool IsUtf8(Stream stream)
|
|
{
|
|
int b;
|
|
while ((b = stream.ReadByte()) != -1)
|
|
{
|
|
if ((b & 0x80) == 0) // 0xxxxxxx
|
|
{
|
|
continue;
|
|
}
|
|
else if ((b & 0xE0) == 0xC0) // 110xxxxx 10xxxxxx
|
|
{
|
|
if (!IsValidUtf8ContinuationByte(stream)) return false;
|
|
}
|
|
else if ((b & 0xF0) == 0xE0) // 1110xxxx 10xxxxxx 10xxxxxx
|
|
{
|
|
if (!IsValidUtf8ContinuationByte(stream) || !IsValidUtf8ContinuationByte(stream)) return false;
|
|
}
|
|
else if ((b & 0xF8) == 0xF0) // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
{
|
|
if (!IsValidUtf8ContinuationByte(stream) || !IsValidUtf8ContinuationByte(stream) || !IsValidUtf8ContinuationByte(stream)) return false;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static bool IsValidUtf8ContinuationByte(Stream stream)
|
|
{
|
|
int b = stream.ReadByte();
|
|
return b != -1 && (b & 0xC0) == 0x80; // 10xxxxxx
|
|
}
|
|
|
|
private static bool IsUtf16(Stream stream, out Encoding encoding)
|
|
{
|
|
encoding = Encoding.Default;
|
|
|
|
if (stream.Length >= 2)
|
|
{
|
|
// Read the first two bytes
|
|
int b0 = stream.ReadByte();
|
|
int b1 = stream.ReadByte();
|
|
|
|
// Check for UTF-16 BOM (Byte Order Mark)
|
|
if (b0 == 0xFF && b1 == 0xFE)
|
|
{
|
|
encoding = Encoding.Unicode;
|
|
return true; // UTF-16LE
|
|
}
|
|
if (b0 == 0xFE && b1 == 0xFF)
|
|
{
|
|
encoding = Encoding.BigEndianUnicode;
|
|
return true; // UTF-16BE
|
|
}
|
|
|
|
// Reset the stream position
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
|
|
// Check for common UTF-16 patterns
|
|
byte[] buffer = new byte[2];
|
|
while (stream.Read(buffer, 0, 2) == 2)
|
|
{
|
|
if (buffer[0] == 0x00 && buffer[1] != 0x00)
|
|
{
|
|
encoding = Encoding.BigEndianUnicode;
|
|
return true; // Likely UTF-16BE
|
|
}
|
|
if (buffer[0] != 0x00 && buffer[1] == 0x00)
|
|
{
|
|
encoding = Encoding.Unicode;
|
|
return true; // Likely UTF-16LE
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool IsAscii(Stream stream)
|
|
{
|
|
int b;
|
|
while ((b = stream.ReadByte()) != -1)
|
|
{
|
|
// Latin1 includes byte values from 0x00 to 0xFF
|
|
if (b > 0x7F)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static bool IsLatin1(Stream stream)
|
|
{
|
|
int b;
|
|
while ((b = stream.ReadByte()) != -1)
|
|
{
|
|
// Latin1 includes byte values from 0x00 to 0xFF
|
|
if (b > 0xFF)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
}
|
|
#endif // !NOFILES
|
|
#endregion Buffer classes
|
|
|
|
// ==============================================================
|
|
// ============ class CodePageHandling =============
|
|
// ==============================================================
|
|
#if (!NOFILES)
|
|
public static class CodePageHandling
|
|
{
|
|
public static int GetCodePage(string option)
|
|
{
|
|
string command = option.ToUpperInvariant();
|
|
if (command.StartsWith("CodePage:", StringComparison.OrdinalIgnoreCase))
|
|
command = command.Substring(9);
|
|
try
|
|
{
|
|
if (command.Equals("RAW"))
|
|
return -1;
|
|
else if (command.Equals("GUESS"))
|
|
return -2;
|
|
else if (command.Equals("DEFAULT"))
|
|
return 0;
|
|
else if (char.IsDigit(command[0]))
|
|
return int.Parse(command, CultureInfo.InvariantCulture);
|
|
else
|
|
{
|
|
Encoding enc = Encoding.GetEncoding(command);
|
|
return enc.CodePage;
|
|
}
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Console.Error.WriteLine(
|
|
"Invalid format \"{0}\", using machine default", option);
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
Console.Error.WriteLine(
|
|
"Unknown code page \"{0}\", using machine default", option);
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
#endif // !NOFILES
|
|
|
|
// End of code copied from embedded resource
|
|
}
|