public static Token? TryMatch(CharBuffer cs)
{
if (!cs.TryExpect(StringTag)) { return null; }
var errPos = cs.FilePosition;
StringBuilder sb = new StringBuilder(64);
sb.Append(cs.Consume(StringTag.Length).ToArray());
while (!cs.TryExpect(StringTag))
{
if (cs.End)
{
break;
}
if (cs.TryExpect('\\'))
{
sb.Append(cs.Consume());
}
sb.Append(cs.Consume());
}
if (!cs.TryExpect(StringTag))
{
throw Parser.CreateParseError(errPos, Constants.ParseErrorStringNotClosed);
}
else
{
sb.Append(cs.Consume(3).ToArray());
return new Token(TokenType.MultilineString, sb.ToString());
}
}
public void CanReadCompleContent()
{
// Arrange
var content = "This is";
var sb = new StringBuilder();
var sr = new StreamReader(content.ToStream());
var lab = new CharBuffer(() =>
{
int read = sr.Read();
return read != -1 ? new char?((char)read) : new char?();
}, 3);
// Act
while (lab.HasNext())
{
sb.Append(lab.PeekAt(0));
lab.Consume();
}
sb.Append(lab.PeekAt(0));
// Assert
sb.ToString().Should().Be(content);
}
internal static Token? TryMatch(CharBuffer cs)
{
StringBuilder sb = new StringBuilder(256);
if (!cs.TryExpect(StringTag))
{
return null;
}
var errPos = cs.FilePosition;
if (cs.TryExpectAt(1, StringTag) && cs.TryExpectAt(2, StringTag))
{
return MultilineLiteralStringMatcher.TryMatch(cs);
}
sb.Append(cs.Consume());
while (!cs.End && !cs.TryExpect(StringTag))
{
sb.Append(cs.Consume());
}
if (!cs.TryExpect(StringTag))
{
throw Parser.CreateParseError(errPos, Constants.ParseErrorStringNotClosed);
}
else
{
sb.Append(cs.Consume());
return new Token(TokenType.LiteralString, sb.ToString());
}
}
private static void SerializeCustomer(CharBuffer b, Marlee.Jsv.Console.Program.Customer c)
{
b.Write('{');
if (c.Name != null)
{
b.Write("Name:");
WriteString(b, c.Name);
b.Write(',');
}
b.Write("ID:");
b.Write(c.ID);
b.Write(',');
if (c.Roles != null)
{
b.Write("Roles:[");
for (var i = 0; i < c.Roles.Count; i++)
{
WriteString(b, c.Roles[i]);
b.Write(']');
}
b.Write(']');
b.Write(',');
}
if (c.Address != null)
{
SerializeAddress(b, c.Address);
b.Write(',');
}
if (c.PhoneNumbers != null)
{
b.Write("PhoneNumbers:[");
for (var i = 0; i < c.PhoneNumbers.Count; i++)
{
SerializePhoneNumber(b, c.PhoneNumbers[i]);
}
b.Write(']');
b.Write(',');
}
if (c.FirstName != null)
{
b.Write("FirstName:");
WriteString(b, c.FirstName);
b.Write(',');
}
if (c.LastName != null)
{
b.Write("LastName:");
WriteString(b, c.LastName);
b.Write(',');
}
b.Write("Age:");
b.Write(c.Age);
b.Write('}');
}
private char CheckStyle(CharBuffer buffer)
{
return IsStyle(buffer, S1) ? S1 :
IsStyle(buffer, S2) ? S2 :
IsStyle(buffer, S3) ? S3 :
IsStyle(buffer, S4) ? S4 :
NIL;
}
public static string replace(string str, string swap, int start, int count)
{
int capacity = (str.Length + swap.Length) - count;
CharBuffer buffer = new CharBuffer(capacity);
buffer.append(str.Substring(0, start)).append(swap);
buffer.append(str.Substring(start + count));
return buffer.getString();
}
public static string replace(string str, string swap, int start, int count, CharBuffer cb)
{
int len = (str.Length + swap.Length) - count;
cb.clear();
cb.setCapacity(len);
cb.append(str.Substring(0, start)).append(swap);
cb.append(str.Substring(start + count));
return cb.getString();
}
public IEnumerable<StyledToken> Parse(string source)
{
var buffer = new CharBuffer(source);
var spacePos = 0;
while (buffer.MoveNext())
{
var c = buffer.GetCurrent();
if (c == SL && Hyperlinks)
{
if (buffer.GetNext() == SL && buffer.GetPrevious() == DD && spacePos > -1)
{
var sp = spacePos > 0 ? spacePos + 1 : spacePos;
var ep = buffer.Offset - 2;
var str = buffer.GetString(sp, ep - sp + 1);
while (!IsEmptyOrBrace(buffer.GetNext()))
buffer.MoveNext();
yield return new StyledToken(sp, buffer.Offset - sp + 1, TextStyle.Hyperlink);
spacePos = buffer.Offset;
}
}
else if (c == BS && Bold && IsStart(buffer))
{
var a = buffer.SetAnchor();
while (!IsEmpty(buffer.GetNext()))
buffer.MoveNext();
if (buffer.GetCurrent() != BS)
buffer.BackToAnchor();
else
yield return new StyledToken(a, buffer.Offset - a + 1, TextStyle.Style1);
}
else if (c == IS && Italic && IsStart(buffer))
{
var a = buffer.SetAnchor();
while (!IsEmpty(buffer.GetNext()))
buffer.MoveNext();
if (buffer.GetCurrent() != IS)
buffer.BackToAnchor();
else
yield return new StyledToken(a, buffer.Offset - a + 1, TextStyle.Style2);
}
else if (IsSep(c))
spacePos = buffer.Offset;
}
}
protected internal override CoderResult decodeLoop(ByteBuffer @in, CharBuffer @out)
{
while (@in.hasRemaining() && @out.hasRemaining())
{
char ch = (char)(@in.get() & 0xff);
if (ch >= 0xA0)
{
ch = TABLE[ch - 0xA0];
}
@out.put(ch);
}
return @in.hasRemaining() ? CoderResult.OVERFLOW : CoderResult.UNDERFLOW;
}
internal static Token? TryMatch(CharBuffer cs)
{
bool hasPos = cs.TryExpect('+');
bool hasSign = hasPos || cs.TryExpect('-');
if (hasSign || cs.TryExpectInRange('0', '9'))
{
StringBuilder sb = new StringBuilder(16);
sb.Append(cs.Consume());
if (hasSign && !cs.TryExpectInRange('0', '9'))
{
throw Parser.CreateParseError(
cs.FilePosition, $"Failed to read Integer. Expected a number but '{cs.Peek().ToReadable()}' was found instead.");
}
while (!cs.End && (cs.TryExpectInRange('0', '9') || cs.TryExpect('_')))
{
sb.Append(cs.Consume());
}
if (cs.TryExpect('-') && sb.Length == 4 && !hasSign)
{
return DateTimeMatcher.TryMatch(sb, cs);
}
else if (((cs.TryExpect('.') && cs.TryExpectAt(3, ':')) || cs.TryExpect(":")) && !hasPos)
{
return TimespanMatcher.ContinueMatchFromInteger(sb, cs);
}
if (cs.End || cs.TryExpectWhitespace() || cs.TokenDone())
{
return new Token(TokenType.Integer, sb.ToString());
}
else
{
if (cs.TryExpect('E') || cs.TryExpect('e') || cs.TryExpect('.'))
{
return FloatMatcher.Match(sb, cs);
}
else
{
return BareKeyMatcher.TryContinueMatch(sb, cs);
}
}
}
else
{
return null;
}
}
private static void SerializeAddress(CharBuffer b, Marlee.Jsv.Console.Program.Address a)
{
b.Write('{');
if (a.Street != null)
{
b.Write("Street:");
WriteString(b, a.Street);
b.Write(',');
}
b.Write("ID:");
b.Write(a.ID);
b.Write('}');
}
internal static void SerializeCustomerBytes(Marlee.Jsv.Console.Program.Customer c, Stream s)
{
//var byteBuffer = new ByteBuffer(256);
//byteBuffer.WriteInt32(4);
//byteBuffer.WriteChar('{');
//byteBuffer.WriteString("test");
//var s = byteBuffer.ToString();
var byteBuffer = new CharBuffer(256);
SerializeCustomer(byteBuffer, c);
byteBuffer.WriteToStream(s);
//var x = byteBuffer.ToString();
}
private static Token? TryMatchInternal(StringBuilder alreadyMatched, CharBuffer cs)
{
var sb = alreadyMatched ?? new StringBuilder(64);
while (!cs.End && cs.Peek().IsBareKeyChar())
{
sb.Append(cs.Consume());
}
if (sb.Length > 0 && !TokenDone(cs))
{
return Token.CreateUnknownTokenFromFragment(cs, sb);
}
return sb.Length > 0 ? new Token(TokenType.BareKey, sb.ToString()) : default(Token?);
}
public static Token? TryMatch(CharBuffer cs)
{
if (cs.TryExpect(T))
{
cs.Consume(T.Length);
return new Token(TokenType.Bool, T);
}
else if (cs.TryExpect(F))
{
cs.Consume(F.Length);
return new Token(TokenType.Bool, F);
}
else
{
return null;
}
}
internal static Token? Match(StringBuilder beforeFraction, CharBuffer cs)
{
if (cs.TryExpect('.'))
{
beforeFraction.Append(cs.Consume());
var errPos = cs.FilePosition;
var intFrac = IntMatcher.TryMatch(cs);
if (!intFrac.HasValue)
{
throw Parser.CreateParseError(errPos, "Fraction of float is missing.");
}
else if (intFrac.Value.type != TokenType.Integer && intFrac.Value.type != TokenType.Float)
{
throw Parser.CreateParseError(errPos, $"Failed to read float because fraction '{intFrac.Value.value}' is invalid.");
}
beforeFraction.Append(intFrac.Value.value);
}
if (cs.TryExpect('e') || cs.TryExpect('E'))
{
beforeFraction.Append(cs.Consume());
var errPos = cs.FilePosition;
var intPar = IntMatcher.TryMatch(cs);
if (!intPar.HasValue)
{
throw Parser.CreateParseError(errPos, "Exponent of float is missing.");
}
else if (intPar.Value.type != TokenType.Integer)
{
throw Parser.CreateParseError(errPos, $"Failed to read float because exponent '{intPar.Value.value}' is invalid.");
}
beforeFraction.Append(intPar.Value.value);
}
if (cs.TokenDone())
{
return new Token(TokenType.Float, beforeFraction.ToString());
}
else
{
throw Parser.CreateParseError(cs.FilePosition, "Failed to construct float token");
}
}
public IEnumerable<StyledToken> Parse(string source)
{
var buffer = new CharBuffer(source);
while (buffer.MoveNext())
{
var c = buffer.GetCurrent();
if (c == HS && buffer.GetNext() == MM)
{
var ec = CheckStyle(buffer);
if (ec != NIL)
{
var sp = buffer.Offset;
for (;;)
{
if (!buffer.MoveNext())
break;
c = buffer.GetCurrent();
if (c == HS && IsEndStyle(buffer, ec))
{
var ts = ec == S1 ? TextStyle.MultilineStyle1 :
ec == S2 ? TextStyle.MultilineStyle2 :
ec == S3 ? TextStyle.MultilineStyle3 :
ec == S4 ? TextStyle.MultilineStyle4 :
TextStyle.Default;
yield return new StyledToken(sp, 5, TextStyle.Invisible);
yield return new StyledToken(buffer.Offset, 6, TextStyle.Invisible);
yield return new StyledToken(sp + 5, buffer.Offset - sp - 5, ts);
break;
}
}
}
}
}
}
internal static Token? ContinueMatchFromInteger(StringBuilder matchedAlready, CharBuffer cs)
{
var sb = matchedAlready;
if (cs.TryExpect("."))
{
sb.Append(cs.Consume());
sb.Append(cs.ExpectAndConsumeDigit());
sb.Append(cs.ExpectAndConsumeDigit());
}
ExpectColonSperatedSegment(sb, cs);
if (!cs.TokenDone())
{
ExpectColonSperatedSegment(sb, cs);
}
if (!cs.TokenDone() && cs.TryExpect('.'))
{
sb.Append(cs.Consume());
while (!cs.End && cs.TryExpectDigit())
{
sb.Append(cs.Consume());
}
}
if (cs.TokenDone())
{
return new Token(TokenType.Timespan, sb.ToString());
}
else
{
throw Parser.CreateParseError(cs.FilePosition, $"Failed to parse timespan token because unexpected character '{cs.Peek().ToReadable()}' was found.");
}
}
//throws FuseException
public int readlink(String path, CharBuffer link)
{
link.put(fs2.readlink(path));
return 0;
}
public IEnumerable <StyledToken> Parse(string source)
{
var buffer = new CharBuffer(source);
var spacePos = 0;
while (buffer.MoveNext())
{
var c = buffer.GetCurrent();
if (c == SL && Hyperlinks)
{
if (buffer.GetNext() == SL && buffer.GetPrevious() == DD && spacePos > -1)
{
var sp = spacePos > 0 ? spacePos + 1 : spacePos;
var ep = buffer.Offset - 2;
var str = buffer.GetString(sp, ep - sp + 1);
while (!IsEmptyOrBrace(buffer.GetNext()))
{
buffer.MoveNext();
}
yield return(new StyledToken(sp, buffer.Offset - sp + 1, TextStyle.Hyperlink));
spacePos = buffer.Offset;
}
}
else if (c == BS && Bold && IsStart(buffer))
{
var a = buffer.SetAnchor();
while (!IsEmpty(buffer.GetNext()))
{
buffer.MoveNext();
}
if (buffer.GetCurrent() != BS)
{
buffer.BackToAnchor();
}
else
{
yield return(new StyledToken(a, buffer.Offset - a + 1, TextStyle.Style1));
}
}
else if (c == IS && Italic && IsStart(buffer))
{
var a = buffer.SetAnchor();
while (!IsEmpty(buffer.GetNext()))
{
buffer.MoveNext();
}
if (buffer.GetCurrent() != IS)
{
buffer.BackToAnchor();
}
else
{
yield return(new StyledToken(a, buffer.Offset - a + 1, TextStyle.Style2));
}
}
else if (IsSep(c))
{
spacePos = buffer.Offset;
}
}
}
/**
* Decodes bytes into characters. This method is called by the
* {@link #decode(ByteBuffer, CharBuffer, boolean) decode} method.
* <p>
* This method will implement the essential decoding operation, and it won't
* stop decoding until either all the input bytes are read, the output
* buffer is filled, or some exception is encountered. Then it will return a
* <code>CoderResult</code> object indicating the result of current
* decoding operation. The rules to construct the <code>CoderResult</code>
* are the same as for
* {@link #decode(ByteBuffer, CharBuffer, boolean) decode}. When an
* exception is encountered in the decoding operation, most implementations
* of this method will return a relevant result object to the
* {@link #decode(ByteBuffer, CharBuffer, boolean) decode} method, and some
* performance optimized implementation may handle the exception and
* implement the error action itself.
* <p>
* The buffers are scanned from their current positions, and their positions
* will be modified accordingly, while their marks and limits will be
* intact. At most {@link ByteBuffer#remaining() in.remaining()} characters
* will be read, and {@link CharBuffer#remaining() out.remaining()} bytes
* will be written.
* <p>
* Note that some implementations may pre-scan the input buffer and return a
* <code>CoderResult.UNDERFLOW</code> until it receives sufficient input.
*
* @param in
* the input buffer.
* @param out
* the output buffer.
* @return a <code>CoderResult</code> instance indicating the result.
*/
protected abstract CoderResult decodeLoop(ByteBuffer inJ, CharBuffer outJ);
/**
* Decodes bytes starting at the current position of the given input buffer,
* and writes the equivalent character sequence into the given output buffer
* from its current position.
* <p>
* The buffers' position will be changed with the reading and writing
* operation, but their limits and marks will be kept intact.
* <p>
* A <code>CoderResult</code> instance will be returned according to
* following rules:
* <ul>
* <li>{@link CoderResult#OVERFLOW CoderResult.OVERFLOW} indicates that
* even though not all of the input has been processed, the buffer the
* output is being written to has reached its capacity. In the event of this
* code being returned this method should be called once more with an
* <code>out</code> argument that has not already been filled.</li>
* <li>{@link CoderResult#UNDERFLOW CoderResult.UNDERFLOW} indicates that
* as many bytes as possible in the input buffer have been decoded. If there
* is no further input and no remaining bytes in the input buffer then this
* operation may be regarded as complete. Otherwise, this method should be
* called once more with additional input.</li>
* <li>A {@link CoderResult#malformedForLength(int) malformed input} result
* indicates that some malformed input error has been encountered, and the
* erroneous bytes start at the input buffer's position and their number can
* be got by result's {@link CoderResult#length() length}. This kind of
* result can be returned only if the malformed action is
* {@link CodingErrorAction#REPORT CodingErrorAction.REPORT}. </li>
* <li>A {@link CoderResult#unmappableForLength(int) unmappable character}
* result indicates that some unmappable character error has been
* encountered, and the erroneous bytes start at the input buffer's position
* and their number can be got by result's
* {@link CoderResult#length() length}. This kind of result can be returned
* only if the unmappable character action is
* {@link CodingErrorAction#REPORT CodingErrorAction.REPORT}. </li>
* </ul>
* <p>
* The <code>endOfInput</code> parameter indicates that the invoker cannot
* provide further input. This parameter is true if and only if the bytes in
* current input buffer are all inputs for this decoding operation. Note
* that it is common and won't cause an error if the invoker sets false and
* then can't provide more input, while it may cause an error if the invoker
* always sets true in several consecutive invocations. This would make the
* remaining input to be treated as malformed input.
* <p>
* This method invokes the
* {@link #decodeLoop(ByteBuffer, CharBuffer) decodeLoop} method to
* implement the basic decode logic for a specific charset.
*
* @param in
* the input buffer.
* @param out
* the output buffer.
* @param endOfInput
* true if all the input characters have been provided.
* @return a <code>CoderResult</code> instance which indicates the reason
* of termination.
* @throws IllegalStateException
* if decoding has started or no more input is needed in this
* decoding progress.
* @throws CoderMalfunctionError
* if the {@link #decodeLoop(ByteBuffer, CharBuffer) decodeLoop}
* method threw an <code>BufferUnderflowException</code> or
* <code>BufferOverflowException</code>.
*/
public CoderResult decode(ByteBuffer inJ, CharBuffer outJ,
bool endOfInput)
{
/*
* status check
*/
if ((status == FLUSH) || (!endOfInput && status == END)) {
throw new java.lang.IllegalStateException();
}
CoderResult result = null;
// begin to decode
while (true) {
CodingErrorAction action = null;
try {
result = decodeLoop(inJ, outJ);
} catch (BufferOverflowException ex) {
// unexpected exception
throw new CoderMalfunctionError(ex);
} catch (BufferUnderflowException ex) {
// unexpected exception
throw new CoderMalfunctionError(ex);
}
/*
* result handling
*/
if (result.isUnderflow()) {
int remaining = inJ.remaining(); // WHY inJ.remaining() == 1?
status = endOfInput ? END : ONGOING;
if (endOfInput && remaining > 0) {
result = CoderResult.malformedForLength(remaining);
} else {
return result;
}
}
if (result.isOverflow()) {
return result;
}
// set coding error handle action
action = malformAction;
if (result.isUnmappable()) {
action = unmapAction;
}
// If the action is IGNORE or REPLACE, we should continue decoding.
if (action == CodingErrorAction.REPLACE) {
if (outJ.remaining() < replace.length()) {
return CoderResult.OVERFLOW;
}
outJ.put(replace);
} else {
if (action != CodingErrorAction.IGNORE)
return result;
}
inJ.position(inJ.position() + result.length());
}
}
// implementation of canEncode
private bool implCanEncode(CharBuffer cb)
{
if (status == FLUSH || status == INIT) {
status = READY;
}
if (status != READY) {
// niochar.0B=Another encoding process is ongoing\!
throw new java.lang.IllegalStateException("Another encoding process is ongoing!"); //$NON-NLS-1$
}
CodingErrorAction malformBak = malformAction;
CodingErrorAction unmapBak = unmapAction;
onMalformedInput(CodingErrorAction.REPORT);
onUnmappableCharacter(CodingErrorAction.REPORT);
bool result = true;
try {
this.encode(cb);
} catch (CharacterCodingException e) {
result = false;
}
onMalformedInput(malformBak);
onUnmappableCharacter(unmapBak);
reset();
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Lexer"/> class.
/// </summary>
/// <param name="value">The value.</param>
protected Lexer(string value)
{
_buffer = new CharBuffer(value);
_states = new Stack<int>();
}
public override int read(CharBuffer target)
{
throw new System.NotSupportedException("read(CharBuffer)");
}
public ByteBuffer encode(CharBuffer prm1)
{
return(default(ByteBuffer));
}
public CoderResult encode(CharBuffer prm1, ByteBuffer prm2, bool prm3)
{
return(default(CoderResult));
}
protected virtual CoderResult encodeLoop(CharBuffer prm1, ByteBuffer prm2)
{
return(default(CoderResult));
}
/// <summary>
/// Read a chiral configuration from a character buffer and progress the
/// buffer. If there is no configuration then <see cref="Unknown"/>
/// is returned. Encountering an invalid permutation designator (e.g.
/// @TB21) or incomplete class (e.g. @T) will throw an invalid smiles
/// exception.
/// </summary>
/// <param name="buffer">a character buffer</param>
/// <returns>the configuration</returns>
internal static Configuration Read(CharBuffer buffer)
{
if (buffer.GetIf('@'))
{
if (buffer.GetIf('@'))
{
return(Configuration.Clockwise);
}
else if (buffer.GetIf('1'))
{
return(Configuration.AntiClockwise);
}
else if (buffer.GetIf('2'))
{
return(Configuration.Clockwise);
}
else if (buffer.GetIf('T'))
{
// TH (tetrahedral) or TB (trigonal bipyramidal)
if (buffer.GetIf('H'))
{
if (buffer.GetIf('1'))
{
return(Configuration.TH1);
}
else if (buffer.GetIf('2'))
{
return(Configuration.TH2);
}
else
{
throw new InvalidSmilesException("invalid permutation designator for @TH, valid values are @TH1 or @TH2:",
buffer);
}
}
else if (buffer.GetIf('B'))
{
int num = buffer.GetNumber();
if (num < 1 || num > 20)
{
throw new InvalidSmilesException("invalid permutation designator for @TB, valid values are '@TB1, @TB2, ... @TB20:'",
buffer);
}
return(tbs[num]);
}
throw new InvalidSmilesException("'@T' is not a valid chiral specification:", buffer);
}
else if (buffer.GetIf('D'))
{
// DB (double bond)
if (buffer.GetIf('B'))
{
if (buffer.GetIf('1'))
{
return(Configuration.DB1);
}
else if (buffer.GetIf('2'))
{
return(Configuration.DB2);
}
else
{
throw new InvalidSmilesException("invalid permutation designator for @DB, valid values are @DB1 or @DB2:",
buffer);
}
}
throw new InvalidSmilesException("'@D' is not a valid chiral specification:", buffer);
}
else if (buffer.GetIf('A'))
{
// allene (extended tetrahedral)
if (buffer.GetIf('L'))
{
if (buffer.GetIf('1'))
{
return(Configuration.AL1);
}
else if (buffer.GetIf('2'))
{
return(Configuration.AL2);
}
else
{
throw new InvalidSmilesException("invalid permutation designator for @AL, valid values are '@AL1 or @AL2':", buffer);
}
}
else
{
throw new InvalidSmilesException("'@A' is not a valid chiral specification:", buffer);
}
}
else if (buffer.GetIf('S'))
{
// square planar
if (buffer.GetIf('P'))
{
if (buffer.GetIf('1'))
{
return(Configuration.SP1);
}
else if (buffer.GetIf('2'))
{
return(Configuration.SP2);
}
else if (buffer.GetIf('3'))
{
return(Configuration.SP3);
}
else
{
throw new InvalidSmilesException("invalid permutation designator for @SP, valid values are '@SP1, @SP2 or @SP3':",
buffer);
}
}
else
{
throw new InvalidSmilesException("'@S' is not a valid chiral specification:", buffer);
}
}
else if (buffer.GetIf('O'))
{
if (buffer.GetIf('H'))
{
// octahedral
int num = buffer.GetNumber();
if (num < 1 || num > 30)
{
throw new InvalidSmilesException("invalid permutation designator for @OH, valud values are '@OH1, @OH2, ... @OH30':", buffer);
}
return(ohs[num]);
}
else
{
throw new InvalidSmilesException("'@O' is not a valid chiral specification:", buffer);
}
}
else
{
return(Configuration.AntiClockwise);
}
}
return(Unknown);
}
public override CharBuffer put(CharBuffer src)
{
throw new ReadOnlyBufferException();
}
internal static Token? TryMatch(StringBuilder matchedAlready, CharBuffer cs)
{
var sb = matchedAlready;
Debug.Assert(cs.TryExpect('-'));
sb.Append(cs.Consume());
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpect('-')) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpect('T')) { sb.Append(cs.Consume()); } else { return FinishDatetimeToken(sb); }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpect(':')) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpect(':')) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpect('Z'))
{
sb.Append(cs.Consume());
if (cs.TokenDone())
{
return FinishDatetimeToken(sb);
}
else
{
return null;
}
}
else if (cs.TryExpect('-') || cs.TryExpect('+'))
{
sb.Append(cs.Consume());
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpect(':')) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TokenDone())
{
return FinishDatetimeToken(sb);
}
else
{
return null;
}
}
else if (cs.TryExpect('.'))
{
sb.Append(cs.Consume());
while (cs.TryExpectDigit())
{
sb.Append(cs.Consume());
}
if (cs.TryExpect('-') || cs.TryExpect('+')) { sb.Append(cs.Consume()); } else { return FinishDatetimeToken(sb); }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpect(':')) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TryExpectDigit()) { sb.Append(cs.Consume()); } else { return null; }
if (cs.TokenDone())
{
return FinishDatetimeToken(sb);
}
else
{
return null;
}
}
else
{
return FinishDatetimeToken(sb);
}
}
private IntPtr ProcOnNotify(IntPtr hwnd, IntPtr lParam)
{
IntPtr hres = IntPtr.Zero;
OFNOTIFY structure = (OFNOTIFY)Marshal.PtrToStructure(lParam, typeof(OFNOTIFY));
switch ((NativeMethods.DialogChangeStatus)structure.hdr_code)
{
case NativeMethods.DialogChangeStatus.CDN_FILEOK: //- 606:
if (this._ignoreSecondFileOkNotification)
{
if (this._fileOkNotificationCount != 0)
{
this._ignoreSecondFileOkNotification = false;
NativeMethods.CriticalSetWindowLong(new HandleRef(this, hwnd), 0, InvalidIntPtr);
hres = InvalidIntPtr;
break;
}
this._fileOkNotificationCount = 1;
}
if (!this.DoFileOk(structure.lpOFN))
{
NativeMethods.CriticalSetWindowLong(new HandleRef(this, hwnd), 0, InvalidIntPtr);
hres = InvalidIntPtr;
}
break;
case NativeMethods.DialogChangeStatus.CDN_TYPECHANGE:
{
OPENFILENAME_I ofn = (OPENFILENAME_I)Marshal.PtrToStructure(structure.lpOFN, typeof(OPENFILENAME_I));
int i = ofn.nFilterIndex;
OnFilterChanged(this, i);
}
break;
case NativeMethods.DialogChangeStatus.CDN_HELP: // - 605:
break;
case NativeMethods.DialogChangeStatus.CDN_FOLDERCHANGE: //- 603:
{
StringBuilder folderPath = new StringBuilder(256);
NativeMethods.SendMessage(new HandleRef(this, structure.hdr_hwndFrom), (int)DialogChangeProperties.CDM_GETFOLDERPATH, (IntPtr)256, folderPath);
OnPathChanged(this, folderPath.ToString());
folderPath.Length = 0;
}
break;
case NativeMethods.DialogChangeStatus.CDN_SHAREVIOLATION: //- 604:
this._ignoreSecondFileOkNotification = true;
this._fileOkNotificationCount = 0;
break;
case NativeMethods.DialogChangeStatus.CDN_SELCHANGE: //- 602:
{
OPENFILENAME_I openfilename_i = (OPENFILENAME_I)Marshal.PtrToStructure(structure.lpOFN, typeof(OPENFILENAME_I));
int num = (int)NativeMethods.UnsafeSendMessage(this._hwndFileDialog, 0x464, IntPtr.Zero, IntPtr.Zero);
if (num > openfilename_i.nMaxFile)
{
int size = num + 0x800;
CharBuffer buffer = CharBuffer.CreateBuffer(size);
IntPtr ptr2 = buffer.AllocCoTaskMem();
Marshal.FreeCoTaskMem(openfilename_i.lpstrFile);
openfilename_i.lpstrFile = ptr2;
openfilename_i.nMaxFile = size;
this._charBuffer = buffer;
Marshal.StructureToPtr(openfilename_i, structure.lpOFN, true);
Marshal.StructureToPtr(structure, lParam, true);
}
StringBuilder filePath = new StringBuilder(256);
NativeMethods.SendMessage(new HandleRef(this, structure.hdr_hwndFrom), (uint)DialogChangeProperties.CDM_GETFILEPATH, (IntPtr)256, filePath);
OnPathChanged(this, filePath.ToString());
filePath.Length = 0;
break;
}
case NativeMethods.DialogChangeStatus.CDN_INITDONE: //- 601:
{
NativeMethods.PostMessage(new HandleRef(this, this._hwndFileDialogEmbedded), MSG_POST_CREATION, IntPtr.Zero, IntPtr.Zero);
}
break;
}
return(hres);
}
//throws CharacterCodingException
/**
* This is a facade method for the encoding operation.
* <p>
* This method encodes the remaining character sequence of the given
* character buffer into a new byte buffer. This method performs a complete
* encoding operation, resets at first, then encodes, and flushes at last.
* <p>
* This method should not be invoked if another encode operation is ongoing.
*
* @param in
* the input buffer.
* @return a new <code>ByteBuffer</code> containing the bytes produced by
* this encoding operation. The buffer's limit will be the position
* of the last byte in the buffer, and the position will be zero.
* @throws IllegalStateException
* if another encoding operation is ongoing.
* @throws MalformedInputException
* if an illegal input character sequence for this charset is
* encountered, and the action for malformed error is
* {@link CodingErrorAction#REPORT CodingErrorAction.REPORT}
* @throws UnmappableCharacterException
* if a legal but unmappable input character sequence for this
* charset is encountered, and the action for unmappable
* character error is
* {@link CodingErrorAction#REPORT CodingErrorAction.REPORT}.
* Unmappable means the Unicode character sequence at the input
* buffer's current position cannot be mapped to a equivalent
* byte sequence.
* @throws CharacterCodingException
* if other exception happened during the encode operation.
*/
public ByteBuffer encode(CharBuffer inJ)
{
if (inJ.remaining() == 0) {
return ByteBuffer.allocate(0);
}
reset();
int length = (int) (inJ.remaining() * averBytes);
ByteBuffer output = ByteBuffer.allocate(length);
CoderResult result = null;
while (true) {
result = encode(inJ, output, false);
if (result==CoderResult.UNDERFLOW) {
break;
} else if (result==CoderResult.OVERFLOW) {
output = allocateMore(output);
continue;
}
checkCoderResult(result);
}
result = encode(inJ, output, true);
checkCoderResult(result);
while (true) {
result = flush(output);
if (result==CoderResult.UNDERFLOW) {
output.flip();
break;
} else if (result==CoderResult.OVERFLOW) {
output = allocateMore(output);
continue;
}
checkCoderResult(result);
output.flip();
if (result.isMalformed()) {
throw new MalformedInputException(result.length());
} else if (result.isUnmappable()) {
throw new UnmappableCharacterException(result.length());
}
break;
}
status = READY;
finished = true;
return output;
}
/// <summary>
/// Builds a <see cref="CharsTrie"/> for the <see cref="Add(string, int)"/>ed data and char-serializes it.
/// Once built, no further data can be <see cref="Add(string, int)"/>ed until <see cref="Clear()"/> is called.
/// </summary>
/// <remarks>
/// A <see cref="CharsTrie"/> cannot be empty. At least one (string, value) pair
/// must have been <see cref="Add(string, int)"/>ed.
/// <para/>
/// Multiple calls to <see cref="Build(Option)"/> or <see cref="BuildCharSequence(Option)"/> return tries or sequences
/// which share the builder's char array, without rebuilding.
/// After <see cref="Clear()"/> has been called, a new array will be used.
/// </remarks>
/// <param name="buildOption">Build option, see <see cref="StringTrieBuilder.Option"/>.</param>
/// <returns>A <see cref="ICharSequence"/> with the char-serialized <see cref="CharsTrie"/> for the <see cref="Add(string, int)"/>ed data.</returns>
/// <stable>ICU 4.8</stable>
public ICharSequence BuildCharSequence(StringTrieBuilder.Option buildOption)
{
BuildChars(buildOption);
return(CharBuffer.Wrap(chars, chars.Length - charsLength, charsLength));
}
private static void ExpectColonSperatedSegment(StringBuilder sb, CharBuffer cs)
{
sb.Append(cs.ExpectAndConsume(':'));
sb.Append(cs.ExpectAndConsumeDigit());
sb.Append(cs.ExpectAndConsumeDigit());
}
/// <summary>
/// Searches the automaton for a symbol sequence equal to <paramref name="word"/>,
/// followed by a separator. The result is a stem (decompressed accordingly
/// to the dictionary's specification) and an optional tag data.
/// </summary>
public IList <WordData> Lookup(string word)
{
byte separator = dictionaryMetadata.Separator;
#pragma warning disable 612, 618
int prefixBytes = sequenceEncoder.PrefixBytes;
#pragma warning restore 612, 618
if (dictionaryMetadata.InputConversionPairs.Any())
{
word = ApplyReplacements(word, dictionaryMetadata.InputConversionPairs);
}
// Reset the output list to zero length.
formsList.Wrap(forms, 0, 0);
// Encode word characters into bytes in the same encoding as the FSA's.
charBuffer = BufferUtils.ClearAndEnsureCapacity(charBuffer, word.Length);
for (int i = 0; i < word.Length; i++)
{
char chr = word[i];
if (chr == separatorChar)
{
// No valid input can contain the separator.
return(formsList);
}
charBuffer.Put(chr);
}
charBuffer.Flip();
try
{
byteBuffer = BufferUtils.CharsToBytes(encoder, charBuffer, byteBuffer);
}
catch (UnmappableInputException)
{
// This should be a rare occurrence, but if it happens it means there is no way
// the dictionary can contain the input word.
return(formsList);
}
// Try to find a partial match in the dictionary.
MatchResult match = matcher.Match(matchResult, byteBuffer
.Array, 0, byteBuffer.Remaining, rootNode);
if (match.Kind == MatchResult.SequenceIsAPrefix)
{
/*
* The entire sequence exists in the dictionary. A separator should
* be the next symbol.
*/
int arc = fsa.GetArc(match.Node, separator);
/*
* The situation when the arc points to a final node should NEVER
* happen. After all, we want the word to have SOME base form.
*/
if (arc != 0 && !fsa.IsArcFinal(arc))
{
// There is such a word in the dictionary. Return its base forms.
int formsCount = 0;
finalStatesIterator.RestartFrom(fsa.GetEndNode(arc));
while (finalStatesIterator.MoveNext())
{
ByteBuffer bb = finalStatesIterator.Current;
byte[] ba = bb.Array;
int bbSize = bb.Remaining;
if (formsCount >= forms.Length)
{
//forms = Arrays.CopyOf(forms, forms.Length + EXPAND_SIZE);
Array.Resize(ref forms, forms.Length + ExpandSize);
for (int k = 0; k < forms.Length; k++)
{
if (forms[k] == null)
{
forms[k] = new WordData(decoder);
}
}
}
/*
* Now, expand the prefix/ suffix 'compression' and store
* the base form.
*/
WordData wordData = forms[formsCount++];
if (!dictionaryMetadata.OutputConversionPairs.Any())
{
wordData.Update(byteBuffer, word);
}
else
{
wordData.Update(byteBuffer, ApplyReplacements(word, dictionaryMetadata.OutputConversionPairs));
}
/*
* Find the separator byte's position splitting the inflection instructions
* from the tag.
*/
Debug.Assert(prefixBytes <= bbSize, sequenceEncoder.GetType() + " >? " + bbSize);
int sepPos;
for (sepPos = prefixBytes; sepPos < bbSize; sepPos++)
{
if (ba[sepPos] == separator)
{
break;
}
}
/*
* Decode the stem into stem buffer.
*/
wordData.stemBuffer = sequenceEncoder.Decode(wordData.stemBuffer,
byteBuffer,
ByteBuffer.Wrap(ba, 0, sepPos));
// Skip separator character.
sepPos++;
/*
* Decode the tag data.
*/
int tagSize = bbSize - sepPos;
if (tagSize > 0)
{
wordData.tagBuffer = BufferUtils.ClearAndEnsureCapacity(wordData.tagBuffer, tagSize);
wordData.tagBuffer.Put(ba, sepPos, tagSize);
wordData.tagBuffer.Flip();
}
}
formsList.Wrap(forms, 0, formsCount);
}
}
else
{
/*
* this case is somewhat confusing: we should have hit the separator
* first... I don't really know how to deal with it at the time
* being.
*/
}
return(formsList);
}
//throws FuseException
public int readlink(String path, CharBuffer link)
{
N n = lookup(path);
if (n is L)
{
link.append(new StringJ(((L)n).link));
return 0;
}
return Errno.ENOENT;
}
protected virtual CoderResult implFlush(CharBuffer prm1)
{
return(default(CoderResult));
}
/**
* Flushes this decoder.
*
* This method will call {@link #implFlush(CharBuffer) implFlush}. Some
* decoders may need to write some characters to the output buffer when they
* have read all input bytes; subclasses can override
* {@link #implFlush(CharBuffer) implFlush} to perform the writing operation.
* <p>
* The maximum number of written bytes won't be larger than
* {@link CharBuffer#remaining() out.remaining()}. If some decoder wants to
* write more bytes than an output buffer's remaining space allows, then a
* <code>CoderResult.OVERFLOW</code> will be returned, and this method
* must be called again with a character buffer that has more remaining
* space. Otherwise this method will return
* <code>CoderResult.UNDERFLOW</code>, which means one decoding process
* has been completed successfully.
* <p>
* During the flush, the output buffer's position will be changed
* accordingly, while its mark and limit will be intact.
*
* @param out
* the given output buffer.
* @return <code>CoderResult.UNDERFLOW</code> or
* <code>CoderResult.OVERFLOW</code>.
* @throws IllegalStateException
* if this decoder hasn't read all input bytes during one
* decoding process, which means neither after calling
* {@link #decode(ByteBuffer) decode(ByteBuffer)} nor after
* calling {@link #decode(ByteBuffer, CharBuffer, boolean)
* decode(ByteBuffer, CharBuffer, boolean)} with true as value
* for the last boolean parameter.
*/
public CoderResult flush(CharBuffer outJ)
{
if (status != END && status != INIT) {
throw new java.lang.IllegalStateException();
}
CoderResult result = implFlush(outJ);
if (result == CoderResult.UNDERFLOW) {
status = FLUSH;
}
return result;
}
public CoderResult flush(CharBuffer prm1)
{
return(default(CoderResult));
}
/**
* Flushes this decoder. The default implementation does nothing and always
* returns <code>CoderResult.UNDERFLOW</code>; this method can be
* overridden if needed.
*
* @param out
* the output buffer.
* @return <code>CoderResult.UNDERFLOW</code> or
* <code>CoderResult.OVERFLOW</code>.
*/
protected CoderResult implFlush(CharBuffer outJ)
{
return CoderResult.UNDERFLOW;
}
/// <summary>
/// Encodes as many characters as possible from the given input buffer,
/// writing the results to the given output buffer.
///
/// <para> The buffers are read from, and written to, starting at their current
/// positions. At most <seealso cref="Buffer#remaining in.remaining()"/> characters
/// will be read and at most <seealso cref="Buffer#remaining out.remaining()"/>
/// bytes will be written. The buffers' positions will be advanced to
/// reflect the characters read and the bytes written, but their marks and
/// limits will not be modified.
///
/// </para>
/// <para> In addition to reading characters from the input buffer and writing
/// bytes to the output buffer, this method returns a <seealso cref="CoderResult"/>
/// object to describe its reason for termination:
///
/// <ul>
///
/// </para>
/// <li><para> <seealso cref="CoderResult#UNDERFLOW"/> indicates that as much of the
/// input buffer as possible has been encoded. If there is no further
/// input then the invoker can proceed to the next step of the
/// <a href="#steps">encoding operation</a>. Otherwise this method
/// should be invoked again with further input. </para></li>
///
/// <li><para> <seealso cref="CoderResult#OVERFLOW"/> indicates that there is
/// insufficient space in the output buffer to encode any more characters.
/// This method should be invoked again with an output buffer that has
/// more <seealso cref="Buffer#remaining remaining"/> bytes. This is
/// typically done by draining any encoded bytes from the output
/// buffer. </para></li>
///
/// <li><para> A {@link CoderResult#malformedForLength
/// malformed-input} result indicates that a malformed-input
/// error has been detected. The malformed characters begin at the input
/// buffer's (possibly incremented) position; the number of malformed
/// characters may be determined by invoking the result object's {@link
/// CoderResult#length() length} method. This case applies only if the
/// <seealso cref="#onMalformedInput malformed action"/> of this encoder
/// is <seealso cref="CodingErrorAction#REPORT"/>; otherwise the malformed input
/// will be ignored or replaced, as requested. </para></li>
///
/// <li><para> An {@link CoderResult#unmappableForLength
/// unmappable-character} result indicates that an
/// unmappable-character error has been detected. The characters that
/// encode the unmappable character begin at the input buffer's (possibly
/// incremented) position; the number of such characters may be determined
/// by invoking the result object's <seealso cref="CoderResult#length() length"/>
/// method. This case applies only if the {@link #onUnmappableCharacter
/// unmappable action} of this encoder is {@link
/// CodingErrorAction#REPORT}; otherwise the unmappable character will be
/// ignored or replaced, as requested. </para></li>
///
/// </ul>
///
/// In any case, if this method is to be reinvoked in the same encoding
/// operation then care should be taken to preserve any characters remaining
/// in the input buffer so that they are available to the next invocation.
///
/// <para> The <tt>endOfInput</tt> parameter advises this method as to whether
/// the invoker can provide further input beyond that contained in the given
/// input buffer. If there is a possibility of providing additional input
/// then the invoker should pass <tt>false</tt> for this parameter; if there
/// is no possibility of providing further input then the invoker should
/// pass <tt>true</tt>. It is not erroneous, and in fact it is quite
/// common, to pass <tt>false</tt> in one invocation and later discover that
/// no further input was actually available. It is critical, however, that
/// the final invocation of this method in a sequence of invocations always
/// pass <tt>true</tt> so that any remaining unencoded input will be treated
/// as being malformed.
///
/// </para>
/// <para> This method works by invoking the <seealso cref="#encodeLoop encodeLoop"/>
/// method, interpreting its results, handling error conditions, and
/// reinvoking it as necessary. </para>
///
/// </summary>
/// <param name="in">
/// The input character buffer
/// </param>
/// <param name="out">
/// The output byte buffer
/// </param>
/// <param name="endOfInput">
/// <tt>true</tt> if, and only if, the invoker can provide no
/// additional input characters beyond those in the given buffer
/// </param>
/// <returns> A coder-result object describing the reason for termination
/// </returns>
/// <exception cref="IllegalStateException">
/// If an encoding operation is already in progress and the previous
/// step was an invocation neither of the <seealso cref="#reset reset"/>
/// method, nor of this method with a value of <tt>false</tt> for
/// the <tt>endOfInput</tt> parameter, nor of this method with a
/// value of <tt>true</tt> for the <tt>endOfInput</tt> parameter
/// but a return value indicating an incomplete encoding operation
/// </exception>
/// <exception cref="CoderMalfunctionError">
/// If an invocation of the encodeLoop method threw
/// an unexpected exception </exception>
public CoderResult Encode(CharBuffer @in, ByteBuffer @out, bool endOfInput)
{
int newState = endOfInput ? ST_END : ST_CODING;
if ((State != ST_RESET) && (State != ST_CODING) && !(endOfInput && (State == ST_END)))
{
ThrowIllegalStateException(State, newState);
}
State = newState;
for (;;)
{
CoderResult cr;
try
{
cr = EncodeLoop(@in, @out);
}
catch (BufferUnderflowException x)
{
throw new CoderMalfunctionError(x);
}
catch (BufferOverflowException x)
{
throw new CoderMalfunctionError(x);
}
if (cr.Overflow)
{
return(cr);
}
if (cr.Underflow)
{
if (endOfInput && @in.HasRemaining())
{
cr = CoderResult.MalformedForLength(@in.Remaining());
// Fall through to malformed-input case
}
else
{
return(cr);
}
}
CodingErrorAction action = null;
if (cr.Malformed)
{
action = MalformedInputAction_Renamed;
}
else if (cr.Unmappable)
{
action = UnmappableCharacterAction_Renamed;
}
else
{
Debug.Assert(false, cr.ToString());
}
if (action == CodingErrorAction.REPORT)
{
return(cr);
}
if (action == CodingErrorAction.REPLACE)
{
if (@out.Remaining() < Replacement_Renamed.Length)
{
return(CoderResult.OVERFLOW);
}
@out.Put(Replacement_Renamed);
}
if ((action == CodingErrorAction.IGNORE) || (action == CodingErrorAction.REPLACE))
{
// Skip erroneous input either way
@in.Position(@in.Position() + cr.Length());
continue;
}
Debug.Assert(false);
}
}
public override CharBuffer put(CharBuffer prm1)
{
return(default(CharBuffer));
}
private bool IsEndStyle(CharBuffer buffer, char c)
{
return(buffer.Get(1) == SL && buffer.Get(2) == MM && buffer.Get(3) == c &&
buffer.Get(4) == MM && buffer.Get(5) == HE);
}
