private bool ParseConsts(Unit unit, XmlElement elem, string comment)
{
var name = elem.GetAttribute("name");
var type = elem.GetAttribute("type");
if (String.IsNullOrEmpty(name))
{
return(false);
}
if (String.IsNullOrEmpty(type))
{
type = "int32"; // default type
}
var def = new ConstsDef {
Name = name,
Type = type,
Comment = comment
};
string subComment = null;
var node = elem.FirstChild;
for ( ; node != null; node = node.NextSibling)
{
if (node.NodeType != XmlNodeType.Element)
{
if (node.NodeType == XmlNodeType.Comment)
{
subComment = node.Value.Trim();
}
else
{
subComment = null;
}
continue;
}
var child = (XmlElement)node;
if (child.IsEmpty)
{
continue;
}
switch (child.Name)
{
case "const":
if (ParseConstant(def, child, subComment) == false)
{
return(false);
}
break;
default:
break;
}
subComment = null;
}
unit.Definitions.Add(def);
return(true);
}
private static void PreprocessConsts(ConstsDef def)
{
if (def.Type == "string")
{
foreach (var constant in def.Constants)
{
constant.Value = "\"" + constant.Value + "\"";
}
}
}
private bool ParseConstant(ConstsDef def, XmlElement elem, string comment)
{
var name = elem.GetAttribute("name");
if (String.IsNullOrEmpty(name))
{
return(false);
}
var element = new ConstsDef.Constant {
Name = name,
Value = elem.InnerText.Trim(),
Comment = comment
};
def.Constants.Add(element);
return(true);
}
private Unit Normalize(Document doc)
{
Unit unit = new Unit {
Namespace = doc.Namespace
};
if (doc.References != null)
{
for (int i = 0; i < doc.References.Count; ++i)
{
var r = doc.References[i];
if (!String.IsNullOrEmpty(r.Type) && r.Type.ToLower() == "namespace")
{
var reference = new Reference {
Target = r.Target
};
unit.References.Add(reference);
}
}
}
if (doc.Definitions != null)
{
for (int i = 0; i < doc.Definitions.Count; ++i)
{
var def = doc.Definitions[i];
if (def.Class == "cell" || def.Class == "event")
{
bool isEvent = (def.Class == "event");
CellDef definition = (isEvent ? new EventDef() : new CellDef());
definition.Name = def.Name;
definition.Base = def.Base;
if (!String.IsNullOrEmpty(def.Local) && def.Local.ToLower() == "true")
{
definition.IsLocal = true;
}
if (isEvent)
{
((EventDef)definition).Id = def.Id;
}
if (def.Properties != null)
{
for (int j = 0; j < def.Properties.Count; ++j)
{
var p = def.Properties[j];
var property = new CellDef.Property {
Name = p.Name,
TypeSpec = Types.Parse(p.Type),
DefaultValue = p.Default
};
definition.Properties.Add(property);
}
}
unit.Definitions.Add(definition);
}
else if (def.Class == "consts")
{
var definition = new ConstsDef {
Name = def.Name
};
var type = def.Type;
if (String.IsNullOrEmpty(type))
{
type = "int32";
}
definition.Type = type;
if (def.Elements != null)
{
for (int j = 0; j < def.Elements.Count; ++j)
{
var e = def.Elements[j];
var constant = new ConstsDef.Constant {
Name = e.Name,
Value = e.Value
};
definition.Constants.Add(constant);
}
}
unit.Definitions.Add(definition);
}
}
}
return(unit);
}
private Unit Normalize(Root root)
{
Unit unit = new Unit {
Namespace = root.Namespace
};
if (root.References != null)
{
for (int i = 0; i < root.References.Count; ++i)
{
var r = root.References[i];
if (r.GetType() == typeof(NamespaceRef))
{
var reference = new Reference {
Target = r.Target
};
unit.References.Add(reference);
}
}
}
if (root.Definitions != null)
{
for (int i = 0; i < root.Definitions.Count; ++i)
{
var def = root.Definitions[i];
if (def is Cell)
{
bool isEvent = (def.GetType() == typeof(Event));
Cell c = (Cell)def;
CellDef definition = (isEvent ? new EventDef() : new CellDef());
definition.Name = c.Name;
definition.Base = c.Base;
if (!String.IsNullOrEmpty(c.Local) && c.Local.ToLower() == "true")
{
definition.IsLocal = true;
}
if (isEvent)
{
((EventDef)definition).Id = ((Event)c).Id;
}
if (c.Properties != null)
{
for (int j = 0; j < c.Properties.Count; ++j)
{
var p = c.Properties[j];
var property = new CellDef.Property {
Name = p.Name,
TypeSpec = Types.Parse(p.Type),
DefaultValue = p.Default
};
definition.Properties.Add(property);
}
}
unit.Definitions.Add(definition);
}
else if (def.GetType() == typeof(Consts))
{
var c = (Consts)def;
var definition = new ConstsDef {
Name = c.Name
};
var type = c.Type;
if (String.IsNullOrEmpty(type))
{
type = "int32";
}
definition.Type = type;
if (c.Elements != null)
{
for (int j = 0; j < c.Elements.Count; ++j)
{
var e = c.Elements[j];
var constant = new ConstsDef.Constant {
Name = e.Name,
Value = e.Value
};
definition.Constants.Add(constant);
}
}
unit.Definitions.Add(definition);
}
}
}
return(unit);
}
public override void FormatConsts(ConstsDef def)
{
if (nativeTypes.ContainsKey(def.Type))
{
def.NativeType = nativeTypes[def.Type];
}
else
{
return;
}
PreprocessConsts(def);
FormatComment(0, def.Comment);
Out(0, "public static class {0}", def.Name);
Out(0, "{");
foreach (var constant in def.Constants)
{
FormatComment(1, constant.Comment);
Indent(1);
Writer.Write("public const {0} {1}", def.NativeType, constant.Name);
if (!String.IsNullOrEmpty(constant.Value))
{
Writer.Write(" = {0}", constant.Value);
}
Writer.Write(';');
NewLine();
}
NewLine();
Out(1, "private static ConstsInfo<{0}> info;", def.NativeType);
NewLine();
Out(1, "static {0}()", def.Name);
Out(1, "{");
Out(2, "info = new ConstsInfo<{0}>();", def.NativeType);
foreach (var constant in def.Constants)
{
Out(2, "info.Add(\"{0}\", {1});", constant.Name, constant.Value);
}
Out(1, "}");
NewLine();
Out(1, "public static bool ContainsName(string name)", def.NativeType);
Out(1, "{");
Out(2, "return info.ContainsName(name);");
Out(1, "}");
NewLine();
Out(1, "public static bool ContainsValue({0} value)", def.NativeType);
Out(1, "{");
Out(2, "return info.ContainsValue(value);");
Out(1, "}");
NewLine();
Out(1, "public static string GetName({0} value)", def.NativeType);
Out(1, "{");
Out(2, "return info.GetName(value);");
Out(1, "}");
NewLine();
Out(1, "public static {0} Parse(string name)", def.NativeType);
Out(1, "{");
Out(2, "return info.Parse(name);");
Out(1, "}");
NewLine();
Out(1, "public static bool TryParse(string name, out {0} result)", def.NativeType);
Out(1, "{");
Out(2, "return info.TryParse(name, out result);");
Out(1, "}");
Out(0, "}");
}
public abstract void FormatConsts(ConstsDef def);