public void Build(ParserCompiler compiler, IIntermediateAssembly targetAssembly) { this._targetAssembly = targetAssembly; this._compiler = compiler; this._symbolStore = targetAssembly.DefaultNamespace.Parts.Add().Classes.Add("{0}SymbolStore", this._compiler.Source.Options.AssemblyName); this._singletons = _symbolStore.Parts.Add().Classes.Add("Singletons"); this._identityEnum = targetAssembly.DefaultNamespace.Parts.Add().Enums.Add("{0}Symbols", this._compiler.Source.Options.AssemblyName); _symbolStore.AccessLevel = AccessLevelModifiers.Internal; _symbolStore.SpecialModifier = SpecialClassModifier.Static; _singletons.AccessLevel = AccessLevelModifiers.Internal; _symbolStore.SummaryText = string.Format("Defines the used symbols for the {0} language, effectively each unique set of combinations is outlined within this symbol store.", compiler.Source.Options.GrammarName); }
public void ReferenceDeclaration(IIntermediateEnumType declaration) { }
public string Visit(IIntermediateEnumType @enum, IntermediateNameRequestDetails context) { return(VisitIntermediateType(@enum, context)); }
public void DefineDeclaration(IIntermediateEnumType declaration) { }
public TestLinkerResult Visit(IIntermediateEnumType @enum, ICompilationContext context) { throw new NotImplementedException(); }
void IIntermediateTypeVisitor.Visit(IIntermediateEnumType intermediateType) { this.Translate(intermediateType); }
public string Visit(IIntermediateEnumType @enum, DefaultAssemblyFilenameVisitorContext context) { context.CurrentResult = string.Format(@"{0}\{1}", ToBaselineNamespaceName(@enum.NamespaceName, context), @enum.FullName.Substring(@enum.NamespaceName.Length == 0 ? 0 : @enum.NamespaceName.Length + 1)); return(context.CurrentResult); }
public void DefineDeclaration(IIntermediateEnumType declaration) { this.DefineDeclaration((IIntermediateType)declaration); }
internal RuleEntryChildBranchObjectRelationalMap(IIntermediateEnumType casesEnum, IOilexerGrammarProductionRuleEntry[] implementsSeries, OilexerGrammarFileObjectRelationalMap fileMap, IOilexerGrammarProductionRuleEntry entry) : base(implementsSeries, fileMap, entry) { this.CasesEnum = casesEnum; }
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(IIntermediateEnumType intermediateType);
public void ReferenceDeclaration(IIntermediateEnumType declaration) { this.Formatter.ReferenceDeclaration(declaration); }
public void DefineDeclaration(IIntermediateEnumType declaration) { this.Formatter.DefineDeclaration(declaration); }
public CSharpAssemblyFileInfo Visit(IIntermediateEnumType @enum, CSharpAssemblyFileContext context) { context.CurrentResult.FileName = string.Format(@"{0}\{1}", ToBaselineNamespaceName(@enum.NamespaceName, context), @enum.FullName.Substring(@enum.NamespaceName.Length == 0 ? 0 : @enum.NamespaceName.Length + 1)); return(context.CurrentResult); }
public TransformationKind Visit(IIntermediateEnumType @enum, ITransformationContext context) { throw new NotImplementedException(); }