public StoryboardParserTests()
{
blockFactory = new FakeBlockFactory();
dismissNodes = new();
parsingContext = A.Fake<IParsingContext>(i => i.Strict());
A.CallTo(() => parsingContext.RegisterDismissNode(A<INode>.Ignored))
.Invokes(i => dismissNodes.Add(i.Arguments.Get<INode>(0)));
A.CallTo(() => parsingContext.BlockFactory).Returns(blockFactory);
rootBlockParser = A.Fake<IRootBlockParser>(i => i.Strict());
sceneNavigator = A.Fake<ISceneNavigator>(i => i.Strict());
eventManager = A.Fake<IEventManager>(i => i.Strict());
randomizer = A.Fake<IRandomizer>(i => i.Strict());
navigationState = A.Fake<INavigationState>(i => i.Strict());
variableDictionary = A.Fake<IVariableDictionary>(i => i.Strict());
blockState = A.Fake<IBlockState>(i => i.Strict());
var serviceProvider = A.Fake<IServiceProvider>(i => i.Strict());
A.CallTo(() => serviceProvider.GetService(typeof(IParsingContext))).Returns(parsingContext);
A.CallTo(() => serviceProvider.GetService(typeof(IRootBlockParser))).Returns(rootBlockParser);
A.CallTo(() => serviceProvider.GetService(typeof(ISceneNavigator))).Returns(sceneNavigator);
A.CallTo(() => serviceProvider.GetService(typeof(IEventManager))).Returns(eventManager);
A.CallTo(() => serviceProvider.GetService(typeof(IRandomizer))).Returns(randomizer);
A.CallTo(() => serviceProvider.GetService(typeof(INavigationState))).Returns(navigationState);
A.CallTo(() => serviceProvider.GetService(typeof(IVariableDictionary))).Returns(variableDictionary);
A.CallTo(() => serviceProvider.GetService(typeof(IBlockState))).Returns(blockState);
sut = new StoryboardParser(serviceProvider);
}
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
{
var myContext = new TextParentParsingContext();
await elementParser.ParseAsync(reader, parsingContext, myContext, Settings);
var parsedText = myContext.ParsedText;
parsingContext.SceneContext.Reset();
if (string.IsNullOrWhiteSpace(parsedText))
{
var node = new PauseNode(myContext.When);
parentParsingContext.AddNode(node);
return;
}
var value = int.Parse(parsedText);
if (value <= 0)
{
parsingContext.LogError(reader, "O tempo de espera precisa ser maior que zero.");
return;
}
if (value > 5000)
{
parsingContext.LogError(reader, "O tempo de espera não pode ser maior que 5000.");
return;
}
var timedPauseNode = new TimedPauseNode(TimeSpan.FromMilliseconds(value), myContext.When);
parentParsingContext.AddNode(timedPauseNode);
}
internal ArrayInfo(IParsingContext context)
{
ObjectId = context.ReadInt32();
Length = context.ReadInt32();
Check.That(Length >= 0, "Expected Length >=0, got " + Length);
}
public RootBlockParserTests()
{
reader = A.Dummy <XmlReader>();
context = A.Fake <IParsingContext>(i => i.Strict());
elementParser = A.Fake <IElementParser>(i => i.Strict());
backgroundNodeParser = Helper.FakeParser <IBackgroundNodeParser>("background");
blockNodeParser = Helper.FakeParser <IBlockNodeParser>("do");
pauseNodeParser = Helper.FakeParser <IPauseNodeParser>("pause");
musicNodeParser = Helper.FakeParser <IMusicNodeParser>("music");
protagonistNodeParser = Helper.FakeParser <IProtagonistNodeParser>("protagonist");
personNodeParser = Helper.FakeParser <IPersonNodeParser>("person");
narrationNodeParser = Helper.FakeParser <INarrationNodeParser>("narration");
tutorialNodeParser = Helper.FakeParser <ITutorialNodeParser>("tutorial");
setNodeParser = Helper.FakeParser <ISetNodeParser>("set");
unsetNodeParser = Helper.FakeParser <IUnsetNodeParser>("unset");
sut = new(
elementParser,
musicNodeParser,
backgroundNodeParser,
blockNodeParser,
pauseNodeParser,
protagonistNodeParser,
personNodeParser,
narrationNodeParser,
tutorialNodeParser,
setNodeParser,
unsetNodeParser
);
}
public MethodDefinition(IParsingContext[] parsingContext, string name, TypeReference declaringType)
{
mParsingContext = parsingContext;
Parameters = new List<ParameterDefinition>();
mName = name;
mDeclaringType = declaringType;
}
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
{
var myContext = new BalloonChildParsingContext();
await elementParser.ParseAsync(reader, parsingContext, myContext, Settings);
if (myContext.ParsedText is null)
{
return;
}
var textSourceParsingResult = textSourceParser.Parse(myContext.ParsedText);
if (textSourceParsingResult.IsError)
{
parsingContext.LogError(reader, textSourceParsingResult.ErrorMessage);
return;
}
var textSource = textSourceParsingResult.TextSource;
if (reader.ReadState != ReadState.EndOfFile)
{
await elementParser.ParseAsync(reader, parsingContext, myContext, AggregationSettings);
}
var node = new BalloonTextNode(textSource, BalloonType, myContext.ChoiceNode);
parentParsingContext.AddNode(node);
parsingContext.SceneContext.Reset();
}
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
{
var myContext = new TextParentParsingContext();
await elementParser.ParseAsync(reader, parsingContext, myContext, Settings);
if (myContext.ParsedText is null)
{
return;
}
var value = int.Parse(myContext.ParsedText);
if (value < 1)
{
return;
}
if (value > 30000)
{
parsingContext.LogError(reader, "O limite de tempo não pode ser maior que 30 segundos.");
return;
}
var ctx = (ChoiceParentParsingContext)parentParsingContext;
ctx.Choice.TimeLimit = TimeSpan.FromMilliseconds(value);
}
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
{
var context = new BackgroundContext();
await elementParser.ParseAsync(reader, parsingContext, context, Settings);
if (!string.IsNullOrWhiteSpace(context.ParsedText))
{
var state = new BackgroundState(context.ParsedText, BackgroundType.Image, BackgroundPosition.Left);
var block = parsingContext.BlockFactory.Create(
new BackgroundNode(state, null),
new ScrollNode(null)
);
parentParsingContext.AddNode(new BlockNode(block, context.When));
parsingContext.RegisterDismissNode(DismissNode);
return;
}
if (context.Nodes.Count == 0)
{
parsingContext.LogError(reader, "Nome de imagem ou elemento filho era esperado.");
return;
}
{
var block = parsingContext.BlockFactory.Create(context.Nodes);
parentParsingContext.AddNode(new BlockNode(block, context.When));
parsingContext.RegisterDismissNode(DismissNode);
}
}
public SerializationHeaderRecord(IParsingContext context)
{
RootId = context.ReadInt32();
HeaderId = context.ReadInt32();
MajorVersion = context.ReadInt32();
MinorVersion = context.ReadInt32();
}
public StatementParser(Token[] tokens, IParsingContext[] parsingContexts, MethodDefinition containingMethod)
{
mTokens = tokens;
mParsingContexts = parsingContexts;
mContainingMethod = containingMethod;
Reset();
}
protected virtual void TraceDebug(
IParsingContext <TToken> context,
string messageFormat,
params object[] args)
{
var message = string.Format(CultureInfo.InvariantCulture, messageFormat, args);
Debug.WriteLine("[" + context.BranchId + "] " + message);
}
public string?Parse(XmlReader reader, IParsingContext parsingContext, string value)
{
if (string.IsNullOrWhiteSpace(value))
{
return(null);
}
return(value);
}
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
{
var myContext = new TextParentParsingContext();
await elementParser.ParseAsync(reader, parsingContext, myContext, Settings);
var node = new ScrollNode(myContext.When);
parentParsingContext.AddNode(node);
}
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
{
var myContext = new TextParentParsingContext();
await elementParser.ParseAsync(reader, parsingContext, myContext, Settings);
var ctx = (ChoiceOptionParentParsingContext)parentParsingContext;
ctx.Option.DisabledText = myContext.ParsedText;
}
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
{
var myContext = new TextParentParsingContext();
await elementParser.ParseAsync(reader, parsingContext, myContext, Settings);
var ctx = (ChoiceParentParsingContext)parentParsingContext;
ctx.Choice.RandomOrder = true;
}
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
{
while (await reader.ReadAsync())
{
}
if (ret is not null)
{
parentParsingContext.AddNode(ret);
}
}
public IAttribute?Parse(XmlReader reader, IParsingContext parsingContext)
{
if (ConditionParser.TryParse(reader.Value, out var condition))
{
return(new WhenAttribute(condition));
}
parsingContext.LogError(reader, "Condição 'when' inválida.");
return(null);
}
/// <summary>
/// Matches specific set of tokens.
/// </summary>
/// <param name="context">Parsing context</param>
/// <returns>Original context with consumed tokens or null, if match did not succeed.</returns>
protected sealed override async Task <IReadOnlyCollection <IParsingContext <TToken> > > MatchInternal(
IParsingContext <TToken> context)
{
if (await TryMatch(context))
{
return(new[] { context });
}
return(null);
}
public UnsetNodeParserTests()
{
reader = A.Dummy <XmlReader>();
context = A.Fake <IParsingContext>(i => i.Strict());
parentContext = new();
elementParser = A.Fake <IElementParser>(i => i.Strict());
nameTextParser = A.Fake <INameTextParser>(i => i.Strict());
sut = new(elementParser, nameTextParser);
}
Object IValueHolder.GetValue(IParsingContext context)
{
var elementType = ClassRecordBase.ToRealType(PrimitiveType);
var arr = Array.CreateInstance(elementType, ArrayInfo.Length);
for (var idx = 0; idx < arr.Length; ++idx) {
arr.SetValue(Values[idx].Value, idx);
}
return arr;
}
public SetNodeParserTests()
{
reader = A.Dummy <XmlReader>();
context = A.Fake <IParsingContext>(i => i.Strict());
parentContext = new();
varSetParser = A.Fake <IVarSetParser>(i => i.Strict());
elementParser = A.Fake <IElementParser>(i => i.Strict());
varSetTextParser = A.Fake <IVarSetTextParser>(i => i.Strict());
sut = new(varSetParser, elementParser, varSetTextParser);
}
protected override async Task <bool> TryMatch(IParsingContext <char> context)
{
if (context.TokenStream.CurrentToken == '*')
{
await context.TokenStream.Consume();
return(true);
}
return(false);
}
public IAttribute?Parse(XmlReader reader, IParsingContext parsingContext)
{
var result = conditionParser.Parse(reader.Value);
if (result.Condition is not null)
{
return(new WhenAttribute(result.Condition));
}
parsingContext.LogError(reader, "Condição 'when' inválida. " + result.Message);
return(null);
}
public async Task <List <INode> > ParseAsync(XmlReader reader, IParsingContext parsingContext)
{
var context = new BlockParentParsingContext();
await elementParser.ParseAsync(reader, parsingContext, context, Settings);
if (context.Nodes.Count == 0)
{
parsingContext.LogError(reader, "Elemento filho era esperado.");
}
return(context.Nodes);
}
public ClassInfo(IParsingContext context)
{
ObjectId = context.ReadInt32();
Name = context.ReadString();
var memberCount = context.ReadInt32();
Check.That(memberCount >= 0, "MemberCount MUST be 0 or a positive integer.");
Members = new String[memberCount];
for (var i = 0; i < memberCount; ++i) {
Members[i] = context.ReadString();
}
}
internal ArraySinglePrimitive(IParsingContext context)
{
ArrayInfo = new ArrayInfo(context);
PrimitiveType = (PrimitiveTypeEnumeration) context.ReadByte();
Check.That(PrimitiveType != PrimitiveTypeEnumeration.Null, "PrimitiveType must not be Null.");
Check.That(PrimitiveType != PrimitiveTypeEnumeration.String, "PrimitiveType must not be String.");
Values = new MemberPrimitiveUnTyped[ArrayInfo.Length];
for (var idx = 0; idx < Values.Length; ++idx) {
Values[idx] = new MemberPrimitiveUnTyped(context, PrimitiveType);
}
}
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
{
var myContext = new TextParentParsingContext();
await elementParser.ParseAsync(reader, parsingContext, myContext, Settings);
if (myContext.ParsedText is null)
{
return;
}
var ctx = (ChoiceParentParsingContext)parentParsingContext;
ctx.Choice.Default = myContext.ParsedText;
}
protected override ParsingResult ProcessCharacterImpl(IParsingContext context, char nextChar)
{
ParsingResult finalResult = ParsingResult.Match;
System.Diagnostics.Debug.Assert(currentCharacterIndex < tokenToMatch.Length * 2);
int currentCompareCharacterIndex = currentCharacterIndex % tokenToMatch.Length;
if (nextChar == tokenToMatch[currentCompareCharacterIndex])
{
currentCharacterIndex++;
if (this.currentCharacterIndex == tokenToMatch.Length * 2)
{
if (this.errorState != null)
{
context.CurrentState = this.errorState;
context.Append(this.tokenToMatch);
}
else
{
finalResult = ParsingResult.Done;
}
this.currentCharacterIndex = 0;
}
}
else
{
if (currentCharacterIndex == 0)
{
finalResult = ParsingResult.Miss;
}
else if (currentCompareCharacterIndex == currentCharacterIndex)
{
context.CurrentState = this.errorState;
context.Append(this.tokenToMatch.Substring(0, this.currentCharacterIndex));
finalResult = ParsingResult.Miss;
}
else
{
context.CurrentState = this.nextState;
context.Append(this.tokenToMatch.Substring(0, currentCompareCharacterIndex));
finalResult = ParsingResult.Miss;
}
this.currentCharacterIndex = 0;
}
return(finalResult);
}
public string?Parse(XmlReader reader, IParsingContext parsingContext, string value)
{
if (string.IsNullOrWhiteSpace(value))
{
return(string.Empty);
}
if (!Regex.IsMatch(value, @"^(#[a-f0-9]{6}|black|green|silver|gray|olive|white|yellow|maroon|navy|red|blue|purple|teal|fuchsia|aqua)$", RegexOptions.IgnoreCase))
{
parsingContext.LogError(reader, $"O texto '{value}' não representa uma cor válida.");
return(null);
}
return(value.ToLower());
}
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
{
var myContext = new ChoiceParentParsingContext();
await elementParser.ParseAsync(reader, parsingContext, myContext, Settings);
if (myContext.Choice.Options.Count == 0)
{
parsingContext.LogError(reader, "Nenhuma opção informada.");
return;
}
var ctx = (BalloonChildParsingContext)parentParsingContext;
ctx.ChoiceNode = myContext.Choice;
}
protected override async Task <bool> TryMatch(IParsingContext <char> context)
{
var matched = false;
while (context.TokenStream.CurrentToken == ' ' ||
context.TokenStream.CurrentToken == '\t' ||
context.TokenStream.CurrentToken == '\n' ||
context.TokenStream.CurrentToken == '\r')
{
matched = true;
await context.TokenStream.Consume();
}
return(matched);
}
private ObjectValues Build(IParsingContext context, Object current, ClassInfo type, Object[] values, IDictionary<Int32, ObjectValues> cache)
{
// Check (and return) cached values early so we don't enter an infinite
// loop while resolving references to ourself.
var hasObjectId = current as ISerializedObject;
if (hasObjectId != null && cache.ContainsKey(hasObjectId.ObjectId)) {
return cache[hasObjectId.ObjectId];
}
String libraryName = null;
var hasLibraryId = current as IHasLibraryId;
if (hasLibraryId != null) {
var library = context.GetLibrary(hasLibraryId.LibraryId);
libraryName = library.LibraryName;
}
var target = new ObjectValues(libraryName, type.Name);
if (hasObjectId != null) {
// Store the item in the cache early to avoid infinite loops if
// we have a reference to ourself.
cache[hasObjectId.ObjectId] = target;
}
for(var i = 0; i < values.Length; ++i){
var memberName = type.Members[i];
var value = values[i];
while(value is IValueHolder) {
value = ((IValueHolder)value).GetValue(context);
}
var nestedTypeHolder = value as ITypeHolder;
if (nestedTypeHolder != null) {
var nestedType = nestedTypeHolder.GetClassInfo(context);
var nestedValues = ((ClassRecordBase)value).Values;
Object result;
if (TryBuildSystemType(context, nestedType, nestedValues, out result))
target[memberName] = result;
else
target[memberName] = Build(context, value, nestedType, nestedValues, cache);
} else {
target[memberName] = value;
}
}
return target;
}
protected override async Task <bool> TryMatch(IParsingContext <char> context)
{
var matched = false;
while ((context.TokenStream.CurrentToken >= 'a' && context.TokenStream.CurrentToken <= 'z') ||
(context.TokenStream.CurrentToken >= 'A' && context.TokenStream.CurrentToken <= 'Z') ||
(context.TokenStream.CurrentToken >= '0' && context.TokenStream.CurrentToken <= '9') ||
context.TokenStream.CurrentToken == '_')
{
await context.TokenStream.Consume();
matched = true;
}
return(matched);
}
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
{
var myContext = new BlockParentParsingContext();
await elementParser.ParseAsync(reader, parsingContext, myContext, Settings);
if (myContext.Nodes.Count == 0)
{
parsingContext.LogError(reader, "Elemento filho era esperado.");
return;
}
var block = parsingContext.BlockFactory.Create(myContext.Nodes, myContext.While);
var node = new BlockNode(block, myContext.When);
parentParsingContext.AddNode(node);
}
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
{
var myContext = new TextParentParsingContext();
await elementParser.ParseAsync(reader, parsingContext, myContext, Settings);
var parsedText = myContext.ParsedText;
if (parsedText is null)
{
return;
}
var varSet = new VarSet(parsedText, null);
parentParsingContext.AddNode(new VarSetNode(varSet));
}
/// <summary>
/// Tries to match provided rule one time.
/// </summary>
/// <param name="context">Parsing context</param>
/// <returns>
/// Original branch, if rule doesn't match, otherwise both - original branch and
/// branch with consumed optional match.
/// </returns>
public async Task <IReadOnlyCollection <IParsingContext <TToken> > > Match(IParsingContext <TToken> context)
{
var branchesWithOptionalMatch = await rule.Match(context.Clone());
if (branchesWithOptionalMatch != null && branchesWithOptionalMatch.Count > 0)
{
return
(new List <IParsingContext <TToken> >(branchesWithOptionalMatch)
{
context
});
}
// Optional rule didn't match, return original parsing context
return(new[] { context });
}
protected override async Task <bool> TryMatch(IParsingContext <char> context)
{
while (context.TokenStream.CurrentToken != '"')
{
if ((context.TokenStream.CurrentToken >= '\u0000' && context.TokenStream.CurrentToken <= '\u0021') ||
(context.TokenStream.CurrentToken >= '\u0023' && context.TokenStream.CurrentToken <= '\u005b') ||
(context.TokenStream.CurrentToken >= '\u005d' && context.TokenStream.CurrentToken <= '\uFFFF'))
{
await context.TokenStream.Consume();
continue;
}
else if (context.TokenStream.CurrentToken == '\\')
{
await context.TokenStream.Consume();
if (context.TokenStream.CurrentToken == '\\' ||
context.TokenStream.CurrentToken == '"')
{
await context.TokenStream.Consume();
continue;
}
else if (context.TokenStream.CurrentToken == 'u')
{
await context.TokenStream.Consume();
for (var hexIndex = 0; hexIndex < 4; ++hexIndex)
{
if (context.TokenStream.CurrentToken < '0' && context.TokenStream.CurrentToken > '9' &&
context.TokenStream.CurrentToken < 'A' && context.TokenStream.CurrentToken > 'F')
{
return(false);
}
await context.TokenStream.Consume();
}
continue;
}
}
return(false);
}
return(true);
}
public async Task <INode?> ParseAsync(XmlReader reader, IParsingContext parsingContext)
{
var parsed = await elementParser.ParseAsync(reader, parsingContext);
if (parsed is null)
{
return(null);
}
if (parsed.Block is null || parsed.Block.IsEmpty())
{
parsingContext.LogError(reader, "Nenhum comando de storyboard válido encontrado.");
return(null);
}
return(new BlockNode(parsed.Block, null, null));
}
protected internal static Object ReadPrimitiveValue(IParsingContext context, PrimitiveTypeEnumeration type)
{
switch (type) {
case PrimitiveTypeEnumeration.Boolean:
return context.ReadBoolean();
case PrimitiveTypeEnumeration.Byte:
return context.ReadByte();
case PrimitiveTypeEnumeration.Char:
return context.ReadChar();
case PrimitiveTypeEnumeration.DateTime:
var data = context.ReadInt64();
var dt = DateTime.FromBinary(data);
var dtUtc = dt.ToUniversalTime();
return new DateTime(dtUtc.Ticks, dt.Kind);
case PrimitiveTypeEnumeration.Decimal:
return Decimal.Parse(context.ReadString(), CultureInfo.InvariantCulture);
case PrimitiveTypeEnumeration.Double:
return context.ReadDouble();
case PrimitiveTypeEnumeration.Int16:
return context.ReadInt16();
case PrimitiveTypeEnumeration.Int32:
return context.ReadInt32();
case PrimitiveTypeEnumeration.Int64:
return context.ReadInt64();
case PrimitiveTypeEnumeration.Null:
return null;
case PrimitiveTypeEnumeration.SByte:
return context.ReadSByte();
case PrimitiveTypeEnumeration.Single:
return context.ReadSingle();
case PrimitiveTypeEnumeration.String:
return context.ReadString();
case PrimitiveTypeEnumeration.TimeSpan:
return TimeSpan.FromTicks(context.ReadInt64());
case PrimitiveTypeEnumeration.UInt16:
return context.ReadUInt16();
case PrimitiveTypeEnumeration.UInt32:
return context.ReadUInt32();
case PrimitiveTypeEnumeration.UInt64:
return context.ReadUInt64();
default:
throw new NotSupportedException("Unsupported primitive type " + type);
}
}
public ParsingResult ProcessCharacter(IParsingContext context, char nextChar)
{
ArgumentVerifier.CheckObjectArgument(context, "context");
foreach (IParsingState parsingState in nextStates)
{
ParsingResult result = parsingState.ProcessCharacter(context, nextChar);
if (result != ParsingResult.Miss)
{
if (context.CurrentState == this)
{
// If the current state has not changed in the ProcessCharacter call,
// we should change it now.
context.CurrentState = parsingState;
}
return result;
}
}
context.Append(nextChar);
return ParsingResult.Match;
}
protected virtual ParsingResult ProcessCharacterImpl(IParsingContext context, char nextChar)
{
ParsingResult finalResult = ParsingResult.Match;
System.Diagnostics.Debug.Assert(currentCharacterIndex < tokenToMatch.Length);
if (nextChar == tokenToMatch[currentCharacterIndex])
{
currentCharacterIndex++;
if (this.currentCharacterIndex == tokenToMatch.Length)
{
if (this.nextState != null)
{
context.CurrentState = this.nextState;
}
else
{
finalResult = ParsingResult.Done;
}
this.currentCharacterIndex = 0;
}
}
else
{
if (currentCharacterIndex == 0)
{
finalResult = ParsingResult.Miss;
}
else
{
context.CurrentState = this.errorState;
context.Append(this.tokenToMatch.Substring(0, this.currentCharacterIndex));
finalResult = ParsingResult.Miss;
}
this.currentCharacterIndex = 0;
}
return finalResult;
}
public BinaryLibrary(IParsingContext context)
{
LibraryId = context.ReadInt32();
LibraryName = context.ReadString();
}
public ClassTypeInfo(IParsingContext context)
{
TypeName = context.ReadString();
LibraryId = context.ReadInt32();
}
public ParsingResult ProcessCharacter(IParsingContext context, char nextChar)
{
return result;
}
private ImapDataResponse ParseDataResponse(ByteString line, ref IParsingContext parsingContext)
{
// mailbox-data / message-data / capability-data etc.
// ("*" / tag) SP
var offset = (parsingContext == null) ? line.IndexOf(Octets.SP) + 1 : 0;
var parsedData = ParseData(line, offset, ref parsingContext);
if (parsedData == null)
return null;
else
return ImapDataResponse.Create(parsedData);
}
private ImapResponse ParseResponce(ByteString line, ref IParsingContext parsingContext)
{
// response = *(continue-req / response-data) response-done
// continue-req = "+" SP (resp-text / base64) CRLF
if (line.StartsWith(continueReqMark))
return new ImapCommandContinuationRequest(line.ToString(2, line.Length - 4)); // remove leading "+" SP and trailing CRLF
// greeting = "*" SP (resp-cond-auth / resp-cond-bye) CRLF
// response-done = response-tagged / response-fatal
// response-data = "*" SP (resp-cond-state / resp-cond-bye /
// mailbox-data / message-data / capability-data) CRLF
// response-fatal = "*" SP resp-cond-bye CRLF
// ; Server closes connection immediately
// response-tagged = tag SP resp-cond-state CRLF
// ("*" / tag) SP
var tagSep = line.IndexOf(Octets.SP);
if (tagSep == -1)
// response-done and response-data must contain SP
throw new ImapMalformedResponseException("malformed response-done/response-data", line.ToString());
var untagged = (tagSep == 1 && line[0] == ImapOctets.Asterisk);
// ("OK" / "BAD" / "NO" / "BYE" / "PREAUTH" / text) SP
var respCondSep = line.IndexOf(Octets.SP, tagSep + 1);
var cond = ImapResponseCondition.Undefined;
if (respCondSep == -1) {
if (!untagged)
throw new ImapMalformedResponseException("malformed response-data", line.ToString());
//else
// '* SEARCH\r\n' (mailbox-data which contains no SP)
}
else {
cond = ParseCondition(line.Substring(tagSep + 1, respCondSep - tagSep - 1));
}
if (cond != ImapResponseCondition.Undefined || line.StartsWith(respCondMark)) {
// resp-cond-auth / resp-cond-state / resp-cond-bye
var responseText = ParseRespText((cond == ImapResponseCondition.Undefined)
? line.Substring(tagSep + 1)
: line.Substring(respCondSep + 1));
if (untagged)
return new ImapUntaggedStatusResponse((ImapResponseCondition)cond,
responseText);
else
return new ImapTaggedStatusResponse(line.ToString(0, tagSep),
(ImapResponseCondition)cond,
responseText);
}
// mailbox-data / message-data / capability-data etc.
return ParseDataResponse(line, ref parsingContext);
}
public ParsingResult ProcessCharacter(IParsingContext context, char nextChar)
{
ArgumentVerifier.CheckObjectArgument(context, "context");
return ProcessCharacterImpl(context, nextChar);
}
public MemberTypeInfo(IParsingContext context, Int32 count)
{
BinaryTypeEnums = new BinaryTypeEnumeration[count];
AdditionalInfos = new Object[count];
for (var i = 0; i < count; ++i) {
BinaryTypeEnums[i] = (BinaryTypeEnumeration)context.ReadByte();
}
for (var i = 0; i < count; ++i) {
var binaryType = BinaryTypeEnums[i];
switch (binaryType) {
case BinaryTypeEnumeration.String:
case BinaryTypeEnumeration.StringArray:
case BinaryTypeEnumeration.Object:
case BinaryTypeEnumeration.ObjectArray:
break;
case BinaryTypeEnumeration.Primitive:
case BinaryTypeEnumeration.PrimitiveArray:
AdditionalInfos[i] = (PrimitiveTypeEnumeration)context.ReadByte();
break;
case BinaryTypeEnumeration.SystemClass:
AdditionalInfos[i] = context.ReadString();
break;
case BinaryTypeEnumeration.Class:
AdditionalInfos[i] = new ClassTypeInfo(context);
break;
default:
throw new NotSupportedException("Unsupported BinaryType " + binaryType);
}
}
}
public Object GetValue(IParsingContext context)
{
return Value;
}
public MemberReference(IParsingContext context)
{
IdRef = context.ReadInt32(); ;
}
public BinaryObjectString(IParsingContext context)
{
ObjectId = context.ReadInt32();
Value = context.ReadString();
}
public ParameterDefinition(IParsingContext[] parsingContext)
{
mParsingContext = parsingContext;
}
public Object GetValue(IParsingContext context)
{
return context.GetObject(IdRef);
}
internal MemberPrimitiveTyped(IParsingContext context)
{
PrimitiveType = (PrimitiveTypeEnumeration) context.ReadByte();
Value = ClassRecordBase.ReadPrimitiveValue(context, PrimitiveType);
}
protected ImapData[] ParseData(ByteString line, int offset, ref IParsingContext context)
{
var index = offset;
var c = context as ParsingContext;
if (c == null) {
context = c = new ParsingContext();
}
else {
if (line.Length - index == 2/*CRLF*/) {
if (c.ParenthesesClosed) {
// end of data
context = null;
return c.GetParsed();
}
else {
throw new ImapMalformedDataException("unclosed parenthesis");
}
}
else if (line[index] == Octets.SP) {
index++;
}
}
var bytes = line.ByteArray;
for (;;) {
if (bytes[index] == Octets.SP)
// skip SP
index = line.IndexOfNot(Octets.SP, index);
switch (bytes[index]) {
case ImapOctets.DQuote: {
// quoted
c.AddData(ImapData.CreateTextData(ParseQuotedString(line, ref index)));
break;
}
case ImapOctets.OpenParen: {
// parenthesized begin
c.OpenParenthesis();
index++; // '('
break;
}
case ImapOctets.CloseParen: {
// parenthesized end
c.CloseParenthesis();
index++; // ')'
break;
}
case ImapOctets.OpenBrace:
case ImapOctets.Tilde: {
// literal/literal8
ImapData parsed;
var isLiteral = ParseLiteral((bytes[index] == ImapOctets.Tilde), line, ref index, out parsed);
c.AddData(parsed);
if (isLiteral)
return null; // incomplete
else
break;
}
default: {
// non-quoted
var text = ParseNonQuotedString(line, ref index);
if (nil.EqualsIgnoreCase(text))
c.AddData(ImapData.CreateNilData());
else
c.AddData(ImapData.CreateTextData(text));
break;
}
}
if (line.Length - index == 2/*CRLF*/) {
if (c.ParenthesesClosed) {
// end of data
context = null;
return c.GetParsed();
}
else {
return null; // incomplete
}
}
else {
if (bytes[index] == Octets.SP)
index++;
}
} // for
}
private Boolean TryBuildSystemType(IParsingContext context, ClassInfo classInfo, Object[] values, out Object result)
{
Func<String, Object> V = name => classInfo.GetValue(name, values);
if (classInfo.Name == "System.Guid") {
result = new Guid((Int32)V("_a"), (Int16)V("_b"), (Int16)V("_c"), (Byte)V("_d"), (Byte)V("_e"), (Byte)V("_f"), (Byte)V("_g"), (Byte)V("_h"), (Byte)V("_i"), (Byte)V("_j"), (Byte)V("_k"));
return true;
}
result = null;
return false;
}
public SystemClassWithMembersAndTypes(IParsingContext context)
: base(context)
{
Values = ReadValues(context, MemberTypeInfo);
}
public ImapResponse ReceiveResponse()
{
var line = Receive();
try {
return (dataParsingContext == null)
? ParseResponce(line, ref dataParsingContext)
: ParseDataResponse(line, ref dataParsingContext);
}
catch (Exception ex) {
dataParsingContext = null; // discard context
if (ex is ImapMalformedDataException)
throw new ImapMalformedResponseException(ex.Message);
else
throw;
}
}
internal MemberPrimitiveUnTyped(IParsingContext context, PrimitiveTypeEnumeration primitiveType)
{
Value = ClassRecordBase.ReadPrimitiveValue(context, primitiveType);
}
Object IValueHolder.GetValue(IParsingContext context)
{
return Value;
}
