public string Visit(IIntermediateNamespaceDeclaration @namespace, IntermediateNameRequestDetails context)
{
string name = null;
switch (context)
{
case IntermediateNameRequestDetails.TargetFileName:
this.fileNameLookup.TryGetValue(@namespace.Assembly, out name);
if (this.HtmlContext)
{
name = string.Format("{0}#ns{1:X8}", name, @namespace.GetHashCode());
}
break;
case IntermediateNameRequestDetails.SourceFileName:
name = @namespace.Assembly.FileName;
break;
case IntermediateNameRequestDetails.DisplayName:
name = @namespace.Name;
break;
case IntermediateNameRequestDetails.ReferenceName:
if (this.HtmlContext)
{
name = string.Format("ns{0:X8}", @namespace.GetHashCode());
}
break;
}
return(name);
}
public TestLinkerResult Visit(IIntermediateNamespaceDeclaration @namespace, ICompilationContext context)
{
throw new NotImplementedException();
}
void IIntermediateDeclarationVisitor.Visit(IIntermediateNamespaceDeclaration intermediateDeclaration)
{
this.Translate(intermediateDeclaration);
}
public string Visit(IIntermediateNamespaceDeclaration @namespace, DefaultAssemblyFilenameVisitorContext context)
{
VisitNamespaceParent(@namespace, context);
return(context.CurrentResult);
}
internal static SelectiveTuple <Tuple <IIntermediateClassType, IIntermediateInterfaceType>, IIntermediateEnumType, Tuple <IIntermediateEnumType, IIntermediateEnumType[]> > CreateProgramStructure(IProductionRuleCaptureStructure targetStructure, IIntermediateNamespaceDeclaration owner, OilexerGrammarProductionRuleEntry structureRoot)
{
switch (targetStructure.ResultType)
{
case ResultedDataType.Enumeration:
bool isFlagSet = targetStructure.Values.All(k => k.ResultType == ResultedDataType.FlagEnumerationItem);
bool useBucketName = targetStructure != structureRoot.CaptureStructure;
if (targetStructure.Count > sizeof(SlotType) * 8 && isFlagSet)
{
var chunkedSets = targetStructure.Values.ToArray().Chunk(sizeof(SlotType) * 8);
IIntermediateEnumType[] resultSet = new IIntermediateEnumType[chunkedSets.Length];
IIntermediateEnumType aggregateSet = null;
aggregateSet = owner.Parts.Add().Enums.Add("{0}Cases", targetStructure.ResultedTypeName);
for (int chunkIndex = 0; chunkIndex < chunkedSets.Length; chunkIndex++)
{
var chunkSet = chunkedSets[chunkIndex];
int fieldIndex = 0;
var resultEnum = resultSet[chunkIndex] = owner.Parts.Add().Enums.Add("Valid{0}Set{1}", useBucketName ? targetStructure.BucketName : structureRoot.Name, (chunkIndex + 1));
resultEnum.AccessLevel = AccessLevelModifiers.Public;
resultEnum.Fields.Add("None");
#if x86
resultEnum.ValueType = EnumerationBaseType.UInt32;
#elif x64
resultEnum.ValueType = EnumerationBaseType.UInt64;
#endif
foreach (var element in chunkSet)
{
switch (element.ResultType)
{
case ResultedDataType.EnumerationItem:
resultEnum.Fields.Add(element.BucketName);
break;
case ResultedDataType.FlagEnumerationItem:
var resultField = resultEnum.Fields.Add(element.BucketName, (SlotType)Math.Pow(2, fieldIndex++));
break;
default:
throw new InvalidOperationException("Enums are supposed to yield an " +
"enumeration, result element is of an invalid type.");
}
aggregateSet.Fields.Add(element.BucketName);
}
}
targetStructure.ResultEnumSet = resultSet;
targetStructure.AggregateSetEnum = aggregateSet;
return(new SelectiveTuple <Tuple <IIntermediateClassType, IIntermediateInterfaceType>, IIntermediateEnumType, Tuple <IIntermediateEnumType, IIntermediateEnumType[]> >(Tuple.Create(aggregateSet, resultSet)));
}
else
{
IIntermediateEnumType resultEnum = null;
IIntermediateEnumType aggregateSet = null;
if (isFlagSet)
{
aggregateSet = owner.Enums.Add("{0}Cases", targetStructure.ResultedTypeName);
resultEnum = owner.Enums.Add("Valid{0}", useBucketName ? targetStructure.BucketName : structureRoot.Name);
}
else
{
resultEnum = owner.Enums.Add(targetStructure.ResultedTypeName);
}
resultEnum.AccessLevel = AccessLevelModifiers.Public;
int numNonFlags = (from f in targetStructure.Values
where f.ResultType == ResultedDataType.EnumerationItem
select f).Count();
int flagFieldIndex = isFlagSet ? 0 : (int)(Math.Ceiling(Math.Log10(numNonFlags) / Math.Log10(2)));
int regularFieldIndex = 1;
#if x86
resultEnum.ValueType = EnumerationBaseType.UInt32;
#elif x64
resultEnum.ValueType = EnumerationBaseType.UInt64;
#endif
resultEnum.Fields.Add("None", (SlotType)0);
foreach (var element in targetStructure)
{
switch (element.Value.ResultType)
{
case ResultedDataType.EnumerationItem:
resultEnum.Fields.Add(element.Value.BucketName, (SlotType)regularFieldIndex++);
break;
case ResultedDataType.FlagEnumerationItem:
var resultField = resultEnum.Fields.Add(element.Value.BucketName, (SlotType)Math.Pow(2, flagFieldIndex++));
break;
default:
throw new InvalidOperationException("Enums are supposed to yield an " +
"enumeration, result element is an of invalid type.");
}
if (isFlagSet)
{
aggregateSet.Fields.Add(element.Value.BucketName);
}
}
targetStructure.ResultEnumSet = new IIntermediateEnumType[1] {
resultEnum
};
targetStructure.AggregateSetEnum = aggregateSet;
return(new SelectiveTuple <Tuple <IIntermediateClassType, IIntermediateInterfaceType>, IIntermediateEnumType, Tuple <IIntermediateEnumType, IIntermediateEnumType[]> >(resultEnum));
}
case ResultedDataType.ComplexType:
var resultClass = owner.Classes.Add(targetStructure.ResultedTypeName);
var resultInterface = owner.Interfaces.Add("I{0}", targetStructure.ResultedTypeName);
resultInterface.AccessLevel = AccessLevelModifiers.Public;
resultClass.AccessLevel = AccessLevelModifiers.Internal;
resultClass.ImplementedInterfaces.ImplementInterfaceQuick(resultInterface);
targetStructure.ResultClass = resultClass;
targetStructure.ResultInterface = resultInterface;
foreach (var element in targetStructure.Values)
{
IType simpleType;
switch (element.ResultType)
{
case ResultedDataType.Enumeration:
case ResultedDataType.ComplexType:
IProductionRuleCaptureStructure cts = element as IProductionRuleCaptureStructure;
if (cts == null)
{
throw new InvalidOperationException("Complex types are supposed to be IProductionRuleCaptureStructure instances.");
}
cts.ResultedTypeName = string.Format("{0}{1}", targetStructure.ResultedTypeName, cts.Name);
var currentResult = CreateProgramStructure(cts, owner, structureRoot);
currentResult.Visit(
dualClassInterface =>
{
var interfaceProp = resultInterface.Properties.Add(new TypedName(cts.BucketName, dualClassInterface.Item2), true, false);
var classProp = resultClass.Properties.Add(new TypedName(cts.BucketName, dualClassInterface.Item2), true, false);
classProp.AccessLevel = AccessLevelModifiers.Public;
var classField = resultClass.Fields.Add(new TypedName("_{0}", dualClassInterface.Item2, LowerFirstCharacter(cts.BucketName)));
classField.AccessLevel = AccessLevelModifiers.Private;
classProp.GetMethod.Return(classField.GetReference());
cts.AssociatedField = classField;
},
enumeration =>
{
var interfaceProp = resultInterface.Properties.Add(new TypedName(cts.BucketName, enumeration), true, false);
var classProp = resultClass.Properties.Add(new TypedName(cts.BucketName, enumeration), true, false);
classProp.AccessLevel = AccessLevelModifiers.Public;
var classField = resultClass.Fields.Add(new TypedName("_{0}", enumeration, LowerFirstCharacter(cts.BucketName)));
classField.AccessLevel = AccessLevelModifiers.Private;
classProp.GetMethod.Return(classField.GetReference());
cts.AssociatedField = classField;
},
aggregateWithValidSet =>
{
var enumeration = aggregateWithValidSet.Item1;
var interfaceProp = resultInterface.Properties.Add(new TypedName(cts.BucketName, enumeration), true, false);
var classProp = resultClass.Properties.Add(new TypedName(cts.BucketName, enumeration), true, false);
classProp.AccessLevel = AccessLevelModifiers.Public;
var classField = resultClass.Fields.Add(new TypedName("_{0}", enumeration, LowerFirstCharacter(cts.BucketName)));
classField.AccessLevel = AccessLevelModifiers.Private;
classProp.GetMethod.Return(classField.GetReference());
cts.AssociatedField = classField;
},
() => { throw new InvalidOperationException("Complex types are supposed to yield a complex type, result type unknown"); });
break;
case ResultedDataType.EnumerationItem:
case ResultedDataType.Flag:
simpleType = owner.IdentityManager.ObtainTypeReference(RuntimeCoreType.Boolean);
goto simpleType;
case ResultedDataType.Counter:
simpleType = owner.IdentityManager.ObtainTypeReference(RuntimeCoreType.Int32);
goto simpleType;
case ResultedDataType.Character:
simpleType = owner.IdentityManager.ObtainTypeReference(RuntimeCoreType.Char);
goto simpleType;
case ResultedDataType.String:
simpleType = owner.IdentityManager.ObtainTypeReference(RuntimeCoreType.String);
goto simpleType;
default:
break;
}
continue;
simpleType:
{
var interfaceProp = resultInterface.Properties.Add(new TypedName(element.BucketName, simpleType), true, false);
var classProp = resultClass.Properties.Add(new TypedName(element.BucketName, simpleType), true, false);
classProp.AccessLevel = AccessLevelModifiers.Public;
var classField = resultClass.Fields.Add(new TypedName("_{0}", simpleType, LowerFirstCharacter(element.BucketName)));
classField.AccessLevel = AccessLevelModifiers.Private;
classProp.GetMethod.Return(classField.GetReference());
element.AssociatedField = classField;
}
}
BuildStructureConstructors(targetStructure, structureRoot, owner.IdentityManager);
return(new SelectiveTuple <Tuple <IIntermediateClassType, IIntermediateInterfaceType>, IIntermediateEnumType, Tuple <IIntermediateEnumType, IIntermediateEnumType[]> >(Tuple.Create(resultClass, resultInterface)));
case ResultedDataType.PassThrough:
return(null);
default:
throw new InvalidOperationException();
}
}
public abstract void Translate(IIntermediateNamespaceDeclaration intermediateDeclaration);
public CSharpAssemblyFileInfo Visit(IIntermediateNamespaceDeclaration @namespace, CSharpAssemblyFileContext context)
{
VisitNamespaceParent(@namespace, context);
return(context.CurrentResult);
}
public TransformationKind Visit(IIntermediateNamespaceDeclaration @namespace, ITransformationContext context)
{
throw new NotImplementedException();
}
