public CodeGenField(string type, string name, DefaultValueInfo defaultValueInfo, int offset)
{
Type = type;
Name = name;
DefaultValueInfo = defaultValueInfo;
Offset = offset;
}
public CodeGenArray(string name, int size, int alignment, string itemType, int length, DefaultValueInfo itemDefaultValueInfo)
: base(name, size, alignment)
{
ItemType = itemType;
Length = length;
ItemDefaultValueInfo = itemDefaultValueInfo;
}
public static CodeGenData Calculate(ParsedData parsedData, ExternStructInfo[] externStructs)
{
var typesMemInfo = new Dictionary <string, TypeMemoryInfo>(Primitives);
foreach (var structInfo in externStructs)
{
DefaultValueInfo dvi;
switch (structInfo.Kind)
{
case ExternStructInfo.StructKind.WithoutValues:
dvi = DefaultValueInfo.WriteZeroes();
break;
case ExternStructInfo.StructKind.WithEnumeratedValues:
dvi = DefaultValueInfo.AssignTypeMember(structInfo.Values[0]);
break;
case ExternStructInfo.StructKind.PlainBuffersStruct:
dvi = DefaultValueInfo.CallWriteDefaultMethod();
break;
default:
throw new ArgumentOutOfRangeException();
}
typesMemInfo.Add(structInfo.Name, new TypeMemoryInfo(structInfo.Size, structInfo.Alignment, dvi));
}
var codeGenTypes = new CodeGenType[parsedData.Types.Length];
for (var i = 0; i < parsedData.Types.Length; i++)
{
CodeGenType codeGenType;
switch (parsedData.Types[i])
{
case ParsedEnum pdEnum:
codeGenType = HandleEnum(pdEnum, typesMemInfo);
break;
case ParsedArray pdArray:
codeGenType = HandleArray(pdArray, typesMemInfo);
break;
case ParsedStruct pdStruct:
codeGenType = HandleStruct(pdStruct, typesMemInfo);
break;
default:
throw new Exception($"Unknown type variant {parsedData.Types[i].GetType().Name}");
}
codeGenTypes[i] = codeGenType;
}
return(new CodeGenData(parsedData.Namespace, codeGenTypes));
}
private void PerformDefaultValueChecks()
{
DefaultValueInfo[] defaultValueInfoList = new DefaultValueInfo[]
{
new DefaultValueInfo()
{
Section = this.fileStoreSettings,
IsSectionEnabled = this.IsDCAFileStoreEnabled,
SectionName = FabricValidatorConstants.SectionNames.DiagnosticFileStore,
ParameterName = FabricValidatorConstants.ParameterNames.LogContainerName,
DefaultValue = FabricValidatorConstants.DefaultFileStoreTraceLocation
},
new DefaultValueInfo()
{
Section = this.fileStoreSettings,
IsSectionEnabled = this.IsDCAFileStoreEnabled,
SectionName = FabricValidatorConstants.SectionNames.DiagnosticFileStore,
ParameterName = FabricValidatorConstants.ParameterNames.CrashDumpContainerName,
DefaultValue = FabricValidatorConstants.DefaultFileStoreCrashDumpLocation
},
new DefaultValueInfo()
{
Section = this.tableStoreSettings,
IsSectionEnabled = this.IsDCATableStoreEnabled,
SectionName = FabricValidatorConstants.SectionNames.DiagnosticTableStore,
ParameterName = FabricValidatorConstants.ParameterNames.TableName,
DefaultValue = FabricValidatorConstants.DefaultTableStoreTableName
}
};
foreach (DefaultValueInfo defaultValueInfo in defaultValueInfoList)
{
if (defaultValueInfo.IsSectionEnabled)
{
if (!defaultValueInfo.Section.ContainsKey(defaultValueInfo.ParameterName))
{
WriteWarning(
FabricValidatorUtility.TraceTag,
"Parameter '{0}' was not specified in section '{1}'. The default value '{2}' will be used for that parameter.",
defaultValueInfo.ParameterName,
defaultValueInfo.SectionName,
defaultValueInfo.DefaultValue);
}
}
}
}
private static CodeGenArray HandleArray(ParsedArray pdArray, IDictionary <string, TypeMemoryInfo> typesMemInfo)
{
if (!typesMemInfo.TryGetValue(pdArray.ItemType, out var itemMemInfo))
{
throw new Exception($"Unknown item type `{pdArray.ItemType}` of array `{pdArray.Name}`");
}
var size = itemMemInfo.Size * pdArray.Length;
var arrayDefaultValue = DefaultValueInfo.CallWriteDefaultMethod();
typesMemInfo.Add(pdArray.Name, new TypeMemoryInfo(size, itemMemInfo.Alignment, arrayDefaultValue));
var itemDefaultValue = itemMemInfo.DefaultValueInfo.WithCustomDefaultValueIfPossible(pdArray.ItemDefaultValue);
return(new CodeGenArray(pdArray.Name, size, itemMemInfo.Alignment, pdArray.ItemType, pdArray.Length, itemDefaultValue));
}
private string GenerateFuncAndCallForProperty(DefaultValueInfo info, bool saveFunction)
{
var propertyName = info.Property is ReferencePropertyInfo ? info.Property.Name + "ID" : info.Property.Name;
return($@"
{{
var defaultValueFunc_{propertyName} = Function<{info.Property.DataStructure.Module}.{info.Property.DataStructure.Name}>.Create({info.Expression});
foreach (var _item in insertedNew)
{{
bool setDefaultValue_{propertyName} = _item.{propertyName} == null;
{DefaultValueCodeGenerator.DefaultValueValidationTag.Evaluate(info.Property.DataStructure)}
if (setDefaultValue_{propertyName})
_item.{propertyName} = defaultValueFunc_{propertyName}(_item);
}}
}}
");
}
private static CodeGenEnum HandleEnum(ParsedEnum pdEnum, IDictionary <string, TypeMemoryInfo> typesMemInfo)
{
if (!typesMemInfo.TryGetValue(pdEnum.UnderlyingType, out var memInfo))
{
throw new Exception($"Invalid base type `{pdEnum.UnderlyingType}` of enum `{pdEnum.Name}`");
}
var items = new CodeGenEnumItem[pdEnum.Items.Length];
for (var i = 0; i < items.Length; i++)
{
items[i] = new CodeGenEnumItem(pdEnum.Items[i].Name, pdEnum.Items[i].Value);
}
var defaultValue = DefaultValueInfo.AssignTypeMember(pdEnum.Items[0].Name);
typesMemInfo.Add(pdEnum.Name, new TypeMemoryInfo(memInfo.Size, memInfo.Size, defaultValue));
return(new CodeGenEnum(pdEnum.Name, memInfo.Size, pdEnum.UnderlyingType, pdEnum.IsFlags, items));
}
private static CodeGenStruct HandleStruct(ParsedStruct pdStruct, IDictionary <string, TypeMemoryInfo> typesMemInfo)
{
if (pdStruct.Fields.Length == 0)
{
throw new Exception($"Struct `{pdStruct.Name}` is zero-sized");
}
var fieldsMemInfo = GetFieldsMemoryInfo(pdStruct, typesMemInfo);
var offset = 0;
var fields = new CodeGenField[pdStruct.Fields.Length];
for (var i = 0; i < fields.Length; i++)
{
var(pdFieldIndex, memInfo) = fieldsMemInfo[i];
var pdField = pdStruct.Fields[pdFieldIndex];
var defaultValue = memInfo.DefaultValueInfo.WithCustomDefaultValueIfPossible(pdField.DefaultValue);
fields[i] = new CodeGenField(pdField.Type, pdField.Name, defaultValue, offset);
offset += memInfo.Size;
}
var unalignedSize = fieldsMemInfo.Sum(fmi => fmi.TypeMemoryInfo.Size);
var alignment = fieldsMemInfo.Max(fmi => fmi.TypeMemoryInfo.Alignment);
var reminder = unalignedSize % alignment;
var padding = reminder == 0 ? 0 : alignment - reminder;
var size = unalignedSize + padding;
var structDefaultValue = DefaultValueInfo.CallWriteDefaultMethod();
typesMemInfo.Add(pdStruct.Name, new TypeMemoryInfo(size, alignment, structDefaultValue));
return(new CodeGenStruct(pdStruct.Name, size, alignment, padding, fields));
}
public TypeMemoryInfo(int size, string defaultValue)
{
Size = size;
Alignment = size;
DefaultValueInfo = DefaultValueInfo.AssignValue(defaultValue);
}
public TypeMemoryInfo(int size, int alignment, DefaultValueInfo defaultValueInfo)
{
Size = size;
Alignment = alignment;
DefaultValueInfo = defaultValueInfo;
}
