protected override void TypesRead(IO.XmlStream s)
{
Types = new List<Type>(s.Cursor.ChildNodes.Count);
foreach (XmlNode node in s.Cursor.ChildNodes)
{
if (node.Name != "type") continue;
s.SaveCursor(node);
Types.Add(new Type(s));
s.RestoreCursor();
}
Types.TrimExcess();
}
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 DefinitionsRead(VertexBuffers owner, IO.XmlStream s)
{
Definitions = new List<Definition>(s.Cursor.ChildNodes.Count);
foreach (XmlNode node in s.Cursor.ChildNodes)
{
if (node.Name != "definition") continue;
s.SaveCursor(node);
Definitions.Add(new Definition(owner, s));
s.RestoreCursor();
}
Definitions.TrimExcess();
}
public Definition(VertexBuffers owner, IO.XmlStream s) : base(owner, s)
{
//s.ReadAttribute("size", 16, ref Size);
if (s.Cursor.ChildNodes.Count > 0)
{
var elems = new List<Element>(s.Cursor.ChildNodes.Count);
foreach (XmlNode node in s.Cursor.ChildNodes)
{
if (node.Name != "element") continue;
s.SaveCursor(node);
elems.Add(new Element(owner, this, s));
s.RestoreCursor();
}
elems.TrimExcess();
Elements = elems.ToArray();
foreach (Element e in Elements) Size += GetElementSize(e);
}
}
public FieldType(IO.XmlStream s)
{
s.ReadAttribute("opcode", 16, ref opcode);
s.ReadAttribute("size", 16, ref sizeOf);
s.ReadAttribute("name", ref name);
s.ReadAttributeOpt("needsDefinition", ref requiresDefinition);
#region Read byte swap codes
foreach (XmlNode n in s.Cursor.ChildNodes)
if (n.Name == "byteSwap")
{
s.SaveCursor(n);
int code = 0;
foreach (XmlNode n2 in s.Cursor.ChildNodes)
{
if (n2.Name != "code") continue;
s.SaveCursor(n2);
s.ReadAttribute("value", 10, ref code);
byteSwapCodes.Add(code);
s.RestoreCursor();
}
s.RestoreCursor();
}
#endregion
}
public ScriptFunction(ProjectState state, IO.XmlStream s) : base(state, s)
{
string return_type_name = null;
s.ReadAttribute("returnType", ref return_type_name);
s.ReadAttributeOpt("help", ref helpString);
s.ReadAttributeOpt("helpArg", ref helpArgString);
s.ReadAttributeOpt("internal", ref IsInternal);
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "arg") continue;
s.SaveCursor(n);
args.Add(new ScriptFunctionArg(this, state, s));
s.RestoreCursor();
}
if (!state.scriptingInterface.Types.Contains(return_type_name))
throw new Debug.ExceptionLog("CheApe: value type '{0}' does not exist", return_type_name);
returnType = state.scriptingInterface.GetValueType(return_type_name);
help = state.Compiler.Strings.Add(helpString);
helpArg = state.Compiler.Strings.Add(helpArgString);
}
void ProcessScriptGlobals(ProjectState state, IO.XmlStream s)
{
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "global") continue;
s.SaveCursor(n);
var sg = new ScriptGlobal(state, s);
s.RestoreCursor();
string name_str = sg.ToString();
if (state.scriptingInterface.Globals.Contains(name_str))
{
Debug.LogFile.WriteLine("Engine already contains a {0} named '{1}', ignoring...", "script global", name_str);
continue;
}
try { ScriptGlobals.Add(name_str, sg); }
catch (ArgumentException) { Debug.LogFile.WriteLine(kDuplicateErrorStr, "script global definition", name_str); }
}
}
void ProcessTagDatas(ProjectState state, IO.XmlStream s)
{
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "TagData") continue;
s.SaveCursor(n);
var tagdata = new TagData(state, s);
s.RestoreCursor();
string name_str = tagdata.ToString();
try { Data.Add(name_str, tagdata); }
catch (ArgumentException) { Debug.LogFile.WriteLine(kDuplicateErrorStr, "tag data definition", name_str); }
}
}
static void ProcessStringList(ProjectState state, IO.XmlStream s, Dictionary<string, StringList> listDic,
string elementName, string listTypeName)
{
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != elementName) continue;
s.SaveCursor(n);
var list = new StringList(state, s);
s.RestoreCursor();
string name_str = list.ToString();
try { listDic.Add(name_str, list); }
catch (ArgumentException) { Debug.LogFile.WriteLine(kDuplicateErrorStr, listTypeName, name_str); }
}
}
public Fixup(ProjectState state, IO.XmlStream s) : base(state, s)
{
string temp = string.Empty;
s.ReadAttribute("guerilla", 16, ref addressGuerilla);
s.ReadAttribute("tool", 16, ref addressTool);
s.ReadAttribute("sapien", 16, ref addressSapien);
s.ReadAttribute("type", ref type);
#region Definition
if (type != FixupType.Field && s.ReadAttributeOpt("definition", ref temp))
{
if (type == FixupType.String || type == FixupType.StringPtr)
definition = state.Compiler.RamAddString(temp, out definitionLength).ToString("X8");
else if (type == FixupType.Memory) definition = state.Compiler.RamAddMemory(temp, out definitionLength).ToString("X8");
else if (type == FixupType.Pointer) definition = temp;
definitionGuerilla =
definitionTool =
definitionSapien =
ToPointer();
}
else definition = null;
#endregion
if(definition == null) foreach (XmlNode node in s.Cursor.ChildNodes)
{
if (node.Name == "definition")
{
s.SaveCursor(node);
if (type != FixupType.Field)
{
bool is_string = type == FixupType.String;
// this will be set to false when not all platforms have a definition
bool add_def_memory = true;
if (add_def_memory) add_def_memory = ReadSingleDefinition(state, s, "guerilla", ref definitionGuerilla);
else definitionGuerilla = uint.MaxValue;
if (add_def_memory) add_def_memory = ReadSingleDefinition(state, s, "tool", ref definitionTool);
else definitionTool = uint.MaxValue;
if (add_def_memory) add_def_memory = ReadSingleDefinition(state, s, "sapien", ref definitionSapien);
else definitionSapien = uint.MaxValue;
// Houston, we forgot a platform...
if (!add_def_memory && definitionGuerilla != uint.MaxValue)
{
// TODO: error here
}
}
else
{
foreach (XmlNode fnode in s.Cursor.ChildNodes)
if (fnode.Name == "field")
{
s.SaveCursor(fnode);
field = new Field(state, s);
s.RestoreCursor();
break;
}
}
s.RestoreCursor();
break;
}
}
}
public override void Read(BlamLib.CheApe.ProjectState state, IO.XmlStream s)
{
base.Read(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();
}
}
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); }
}
}
