public VersionSchema(XElement element)
{
Id = element.Attribute("id").Value;
NifVersion = NIFVersion.Parse(element.Attribute("num").Value);
Supported = bool.Parse(element.Attribute("supported")?.Value ?? "true");
if (element.Attribute("bsver") != null)
{
BethesdaVersions = element.Attribute("bsver")
.Value
.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
.Select(n => (uint)Utils.ParseLong(n))
.ToList();
}
if (element.Attribute("user") != null)
{
UserVersions = element.Attribute("user")
.Value
.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
.Select(n => (uint)Utils.ParseLong(n))
.ToList();
}
NIFExtensions = (element.Attribute("ext")?.Value ?? "")
.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
.ToList();
}
void ParseTextToken(TextToken token)
{
var lastPart = CurrentParts.LastOrDefault();
if (lastPart is Part.Operator operatorPart)
{
if (operatorPart.Value is Syntax.Operator.Structural.Member)
{
var memberExpression = new Expression.MemberName(token.Content);
CurrentParts.Add(new Part.Operand(memberExpression));
return;
}
}
if (Utils.TryParseLong(token.Content, out var literalValue))
{
CurrentParts.Add(new Part.Operand(new Literal(literalValue)));
return;
}
if (NIFVersion.TryParse(token.Content, out var nifVersion))
{
CurrentParts.Add(new Part.Operand(new Literal(nifVersion)));
return;
}
var paramtereExpression = new Expression.Parameter(token.Content);
CurrentParts.Add(new Part.Operand(paramtereExpression));
return;
}
public FieldSchema(XElement element)
{
Name = element.Attribute("name").Value;
Type = element.Attribute("type").Value;
MinVersion = NIFVersion.Parse(element.Attribute("ver1"));
MaxVersion = NIFVersion.Parse(element.Attribute("ver2"));
Dimensions = new string[]
{
element.Attribute("arr1")?.Value,
element.Attribute("arr2")?.Value,
}.Where(a => a != null).ToList();
Condition = element.Attribute("cond")?.Value;
VersionCondition = element.Attribute("vercond")?.Value;
OnlyT = element.Attribute("onlyT")?.Value;
ExcludeT = element.Attribute("excludeT")?.Value;
Argument = element.Attribute("arg")?.Value;
Template = element.Attribute("template")?.Value;
}
public SchemaDocument(XElement element)
{
SchemaVersion = NIFVersion.Parse(element.Attribute("version").Value);
var elementsByName = element.Elements()
.ToLookup(e => e.Name);
Tokens = elementsByName["token"]
.Select(e => new TokenSchema(e))
.ToList();
Versions = elementsByName["version"]
.Select(e => new VersionSchema(e))
.ToList();
NiObjects = elementsByName["niobject"]
.Select(e => new NiObjectSchema(e))
.ToDictionary(s => s.Name);
Compounds = elementsByName["compound"]
.Select(e => new CompoundSchema(e))
.ToDictionary(s => s.Name);
Basics = elementsByName["basic"]
.Select(e => new BasicSchema(e))
.ToDictionary(s => s.Name);
Enums = elementsByName["enum"]
.Select(e => new EnumSchema(e))
.ToDictionary(s => s.Name);
Bitfields = elementsByName["bitfield"]
.Select(e => new BitFieldSchema(e))
.ToDictionary(s => s.Name);
Bitflags = elementsByName["bitflags"]
.Select(e => new BitflagsSchema(e))
.ToDictionary(s => s.Name);
TokenLookup = new TokenLookup(Tokens.Concat(StaticTokens));
InheritanceLookup = new InheritanceLookup(NiObjects);
ExpressionLookup = new ExpressionLookup(NiObjects.Values, Compounds.Values, TokenLookup);
ParameterLookup = new ParameterLookup(Compounds.Values, ExpressionLookup);
TypeLookup = new TypeLookup(Compounds.Values, NiObjects.Values);
}
