public Managed Parse(TextParser parser, string defaultName)
{
ResGroup group = new ResGroup(this.context.Resolve<IResourceManager>(), parser.ResourceFile, this.context)
{ BasePath = parser.BasePath };
group.Name = defaultName;
parser.Consume("CIwResGroup");
parser.Consume("{");
for (;;)
{
var attribute = parser.Lexem;
if (attribute == "}")
{
parser.Consume();
break;
}
if (attribute == "name")
{
parser.Consume();
group.Name = parser.ConsumeString();
continue;
}
if (attribute == "shared")
{
parser.Consume();
group.IsShared = parser.ConsumeBool();
continue;
}
if (attribute == "useTemplate")
{
//TODO: make a template handler
parser.Consume();
var ext = parser.ConsumeString();
var name = parser.ConsumeString();
continue;
}
var relPath = attribute.Replace('/', Path.DirectorySeparatorChar);
if (relPath.Length > 2 && relPath[0] == '.' && relPath[1] == Path.DirectorySeparatorChar)
{
relPath = relPath.Substring(2);
}
string fullPath;
if (relPath[0] == Path.DirectorySeparatorChar)
{
var searchPath = parser.BasePath;
do
{
var subpath = relPath.Substring(1);
fullPath = Path.Combine(searchPath, subpath);
if (File.Exists(fullPath))
{
ParseFileReference(parser, @group, fullPath);
continue;
}
searchPath = Path.GetDirectoryName(searchPath);
}
while (!string.IsNullOrEmpty(searchPath));
//fullPath = Path.Combine(searchPath, parser.BasePath);
//ParseFileReference(parser, @group, fullPath);
//continue;
}
else
{
fullPath = Path.Combine(parser.BasePath, relPath);
//if (File.Exists(fullPath))
{
ParseFileReference(parser, @group, fullPath);
continue;
}
}
parser.UnknownLexemError();
}
return group;
}
private static void ParseFileReference(TextParser parser, ResGroup @group, string fullPath)
{
@group.AddFile(fullPath);
parser.ConsumeString();
if (parser.Lexem == "{")
{
//TODO: make a block handler
parser.ConsumeBlock();
}
}
private void ParseGroupResources(BinaryParser parser, ResGroup resGroup)
{
uint numResources = parser.ConsumeUInt32();
while (numResources > 0)
{
uint hash = parser.ConsumeUInt32();
uint resCount = parser.ConsumeUInt32();
bool unknown0 = parser.ConsumeBool();
bool unknown1 = parser.ConsumeBool();
while (resCount > 0)
{
--resCount;
var pos = parser.Position;
uint length = parser.ConsumeUInt32();
object ser = null;
if (!this.context.TryResolveKeyed(hash, typeof(IBinarySerializer), out ser))
{
this.errorHandler.CanNotRead(
parser.BasePath, new FormatException(string.Format("Can't find resource reader for type {0}", hash)));
parser.Skip(length - 4);
continue;
}
var s = (IBinarySerializer)ser;
Managed res = null;
try
{
res = s.Parse(parser);
resGroup.AddResource(res);
}
catch (Exception ex)
{
this.errorHandler.CanNotRead(
parser.BasePath, new FormatException(string.Format("Can't read resource for type {0}", hash), ex));
parser.Position = pos + length;
continue;
}
if (parser.Position != pos + length)
{
throw new FormatException(
string.Format(
"Parse of {0} failed: wrong position by {1} bytes",
(res == null) ? hash.ToString() : res.GetType().Name,
parser.Position - (pos + length)));
//parser.Position = pos + length;
}
}
--numResources;
}
}
private void ParseResGroupMembers(BinaryParser parser, ResGroup resGroup)
{
resGroup.Name = parser.ConsumeStringZ();
resGroup.Flags = parser.ConsumeUInt32();
}
private void ParseChildGroups(BinaryParser parser, ResGroup resGroup)
{
byte num = parser.ConsumeByte();
while (num > 0)
{
string path = parser.ConsumeStringZ();
if (!string.IsNullOrEmpty(path))
{
resGroup.AddFile(path);
}
{
if (0 != parser.ConsumeUInt32())
{
throw new FormatException();
}
}
{
if (0x00001000 != parser.ConsumeInt32())
{
throw new FormatException();
}
}
{
if (0xd9794596 != parser.ConsumeUInt32())
{
throw new FormatException();
}
}
--num;
}
}
