public void Read(BlamLib.CheApe.ProjectState state, IO.XmlStream s)
{
int array_start_depth = 0;
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "field")
{
continue;
}
Field f;
s.SaveCursor(n);
fields.Add(f = new Field(state, s));
s.RestoreCursor();
if (f.TypeIndex == state.kTypeIndexArrayStart)
{
array_start_depth++;
}
else if (f.TypeIndex == state.kTypeIndexArrayEnd)
{
array_start_depth--;
}
}
if (array_start_depth != 0)
{
throw new Debug.ExceptionLog("Unterminated ArrayStart or extra ArrayEnd in '{0}'.{1}{2}",
s.FileName, Program.NewLine, s.Cursor.OuterXml);
}
}
protected override void ProcessDefinition(XmlNode node, BlamLib.CheApe.ProjectState state, BlamLib.IO.XmlStream s)
{
StringIdFieldsInitialize(state);
switch (node.Name)
{
#region Tag Structs
case "structs":
s.SaveCursor(node);
ProcessTagStructs(state, s);
s.RestoreCursor();
break;
#endregion
#region Tag Blocks
case "blocks":
s.SaveCursor(node);
ProcessTagBlocks(state, s);
s.RestoreCursor();
break;
#endregion
#region Tag Groups
case "groups":
s.SaveCursor(node);
ProcessTagGroups(state, s);
s.RestoreCursor();
break;
#endregion
}
}
public TagBlock(BlamLib.CheApe.ProjectState state, IO.XmlStream s) : base(state, s)
{
s.ReadAttribute("maxElements", 10, ref maxElements);
s.ReadAttributeOpt("dontReadChildren", ref DontReadChildren);
mFields.Read(state, s);
}
/// <summary>
/// Constructs a tag group definition from an xml definition node
/// </summary>
/// <param name="state"></param>
/// <param name="s"></param>
public TagGroup(BlamLib.CheApe.ProjectState state, IO.XmlStream s) : base(state, s)
{
block = new TagBlock();
block.DisplayName = name;
string tempName = nameString + "_block";
block.Name = blockName = state.Compiler.Strings.Add(tempName);
block.Read(state, s);
}
public TagStruct(BlamLib.CheApe.ProjectState state, IO.XmlStream s)
{
string name_string = null;
s.ReadAttribute("name", ref name_string);
Name = name_string;
Fields = new FieldContainer();
}
void StringIdFieldsInitialize(BlamLib.CheApe.ProjectState state)
{
if (StringIdFieldDefinition != null)
{
return;
}
// Will add itself to the import state in the ctor
StringIdFieldDefinition = new TagReference(state, kStringIdFieldDefinitionName, true, kStringIdGroupTag);
StringIdFieldHandlePadding = new Field(state, state.kTypeIndexPad, "", kStringIdPadSize.ToString());
}
/// <summary>
/// Constructs a tag group definition from an xml definition node
/// </summary>
/// <param name="state"></param>
/// <param name="s"></param>
public TagGroup(BlamLib.CheApe.ProjectState state, IO.XmlStream s) : base(state, s)
{
s.ReadAttributeOpt("isIncludedInTagGroupsChecksum", ref IsIncludedInTagGroupsChecksum);
block = new TagBlock();
block.DisplayName = name;
string tempName = nameString + "_block";
block.Name = blockName = state.Compiler.Strings.Add(tempName);
block.Read(state, s);
}
public Struct(BlamLib.CheApe.ProjectState state, IO.XmlStream s) : base(state, s)
{
s.ReadAttribute("groupTag", ref groupTag);
block = new TagBlock();
block.DisplayName = name;
string tempName = nameString + "_block";
block.Name = state.Compiler.Strings.Add(tempName);
block.Read(state, s);
}
public Block(BlamLib.CheApe.ProjectState state, IO.XmlStream s) : base(state, s)
{
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "FieldSet")
{
continue;
}
s.SaveCursor(n);
fieldSets.Add(new FieldSet(state, s));
s.RestoreCursor();
}
}
int CalculateSize(BlamLib.CheApe.ProjectState state, Field f, int kUselessPadTypeIndex)
{
if (f.TypeIndex == state.kTypeIndexPad ||
f.TypeIndex == kUselessPadTypeIndex ||
f.TypeIndex == state.kTypeIndexSkip)
{
return(f.ToInt());
}
//else if (f.TypeIndex == kStructTypeIndex)
// ((Struct)state.ImportedBlocks[f.ToString()]).Block.Latest.CalculateSize();
else
{
return(state.GetFieldSize(f.TypeIndex));
}
}
int CalculateSize(BlamLib.CheApe.ProjectState state, Field f)
{
int size = 0;
if (f.TypeIndex == state.kTypeIndexPad || f.TypeIndex == state.kTypeIndexSkip)
{
size = f.ToInt();
}
else
{
size = state.GetFieldSize(f.TypeIndex);
}
return(size);
}
void ProcessTagGroups(BlamLib.CheApe.ProjectState state, IO.XmlStream s)
{
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "TagGroup")
{
continue;
}
s.SaveCursor(n);
var group = new TagGroup(state, s);
s.RestoreCursor();
string name_str = group.ToString();
try { Groups.Add(name_str, group); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag group definition", name_str); }
}
}
void ProcessTagStructs(BlamLib.CheApe.ProjectState state, IO.XmlStream s)
{
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "Struct")
{
continue;
}
s.SaveCursor(n);
var block = new TagStruct(state, s);
s.RestoreCursor();
string name_str = block.ToString();
try { Structs.Add(name_str, block); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag struct definition", name_str); }
}
}
/// <summary>
/// Calculates the block size in bytes via the field for this block
/// eliminating the need for programmers to aid designers in creating
/// the tag group definition files
/// </summary>
/// <returns></returns>
public int CalculateSize(BlamLib.CheApe.ProjectState state)
{
int size = 0;
for (int x = 0; x < fields.Count; x++)
{
if (fields[x].TypeIndex == state.kTypeIndexArrayStart)
{
size += CalculateSizeFromArrayStart(state, ref x);
}
else
{
size += CalculateSize(state, fields[x]);
}
}
return(size);
}
/// <summary>
/// Calculates the block size in bytes via the field for this block
/// eliminating the need for programmers to aid designers in creating
/// the tag group definition files
/// </summary>
/// <returns></returns>
public int CalculateSize(BlamLib.CheApe.ProjectState state)
{
int size = 0;
int kUselessPadTypeIndex = state.Definition.GetTypeIndex("UselessPad");
//int kStructTypeIndex = state.Definition.GetTypeIndex("Struct");
for (int x = 0; x < fields.Count; x++)
{
if (fields[x].TypeIndex == state.kTypeIndexArrayStart)
{
size += CalculateSizeFromArrayStart(state, ref x, kUselessPadTypeIndex);
}
else
{
size += CalculateSize(state, fields[x], kUselessPadTypeIndex);
}
}
return(size);
}
int CalculateSizeFromArrayStart(BlamLib.CheApe.ProjectState state, ref int current_index)
{
int array_size = 0;
int array_count = fields[current_index++].ToInt();
for (; ; current_index++)
{
if (fields[current_index].TypeIndex == state.kTypeIndexArrayStart)
{
array_size += CalculateSizeFromArrayStart(state, ref current_index);
}
else if (fields[current_index].TypeIndex == state.kTypeIndexArrayEnd)
{
break;
}
else
{
array_size += CalculateSize(state, fields[current_index]);
}
}
return(array_size * array_count);
}
public override void Read(BlamLib.CheApe.ProjectState state, IO.XmlStream s)
{
base.Read(state, s);
mFields.Read(state, s);
}
/// <summary>
/// Calculates the block size in bytes via the field for this block
/// eliminating the need for programmers to aid designers in creating
/// the tag group definition files
/// </summary>
/// <returns></returns>
public int CalculateSize(BlamLib.CheApe.ProjectState state)
{
return(mFields.CalculateSize(state));
}
public void Read(BlamLib.CheApe.ProjectState state, IO.XmlStream s)
{
Fields.Read(state, s);
}
protected override void ProcessDefinition(XmlNode node, BlamLib.CheApe.ProjectState state, BlamLib.IO.XmlStream s)
{
StringIdFieldsInitialize(state);
string name_str;
switch (node.Name)
{
#region Tag Structs
case "structs":
s.SaveCursor(node);
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "Struct")
{
continue;
}
s.SaveCursor(n);
TagStruct block = new TagStruct(state, s);
s.RestoreCursor();
name_str = block.ToString();
try { Structs.Add(name_str, block); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag struct definition", name_str); }
}
s.RestoreCursor();
break;
#endregion
#region Tag Blocks
case "blocks":
s.SaveCursor(node);
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "TagBlock")
{
continue;
}
s.SaveCursor(n);
TagBlock block = new TagBlock(state, s);
s.RestoreCursor();
name_str = block.ToString();
try { Blocks.Add(name_str, block); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag block definition", name_str); }
}
s.RestoreCursor();
break;
#endregion
#region Tag Groups
case "groups":
s.SaveCursor(node);
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "TagGroup")
{
continue;
}
s.SaveCursor(n);
TagGroup group = new TagGroup(state, s);
s.RestoreCursor();
name_str = group.ToString();
try { Groups.Add(name_str, group); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag group definition", name_str); }
}
s.RestoreCursor();
break;
#endregion
}
}
public TagBlock(BlamLib.CheApe.ProjectState state, IO.XmlStream s) : base(state, s)
{
s.ReadAttribute("maxElements", 10, ref maxElements);
}
