private static void TestBuildCode(string fileName, string contentTypeName) { ContentType contentType; var expectedOutput = ""; using (var inputReader = File.OpenText(@"..\..\TestFiles\" + fileName + ".xml")) { contentType = new ContentTypeSerializer().Deserialize(inputReader); } using (var goldReader = File.OpenText(@"..\..\TestFiles\" + fileName + ".cs")) { expectedOutput = goldReader.ReadToEnd(); } var configuration = new CodeGeneratorConfiguration(); configuration.TypeMappings.Add(new TypeMapping("1413afcb-d19a-4173-8e9a-68288d2a73b8", "Int32")); var typeConfig = configuration.Get(contentTypeName); typeConfig.BaseClass = "DocumentTypeBase"; typeConfig.Namespace = "Umbraco.CodeGen.Models"; var sb = new StringBuilder(); var writer = new StringWriter(sb); var factory = new DefaultCodeGeneratorFactory(); var dataTypeProvider = new TestDataTypeProvider(); var generator = new CodeGenerator(typeConfig, dataTypeProvider, factory); generator.Generate(contentType, writer); writer.Flush(); Console.WriteLine(sb.ToString()); Assert.AreEqual(expectedOutput, sb.ToString()); }
public override TemplateInfo CompileTemplate(string templateBody, Dictionary<string, Type> globalsTypes, List<Assembly> referencedAssemblies) { lock (_templateInfoCacheLock) { // Generate template program TemplateInfo ti = GenerateTemplateProgram(templateBody, globalsTypes, referencedAssemblies); // Generated template found in cache if (_templateInfoCache.ContainsKey(ti.TemplateKey)) { return _templateInfoCache[ti.TemplateKey]; } // Generate code ICodeGenerator codeGenerator = new CodeGenerator(); ti.GeneratedSourceCode = codeGenerator.GenerateCode(ti); // Generate assembly var assemblyCompiler = new AssemblyGenerator(); Assembly assembly = assemblyCompiler.GenerateAssembly(ti, true, null, null); // Try to load the Render() method from assembly ti.RenderMethod = GetTemplateRenderMethod(assembly, ti); // Try to load the template generator version from assembly ti.GeneratorVersion = GetTemplateGeneratorVersion(assembly, ti); _templateInfoCache.Add(ti.TemplateKey, ti); return ti; } }
public override CodeGenerator DecorateCodeGenerator(CodeGenerator generator, CodeGeneratorContext context) { String type = ChunkHelper.GetModelTypeName(context.ChunkTreeBuilder.Root, "dynamic"); DefaultBaseClass = $"Genny.GennyTemplate<{type}>"; return base.DecorateCodeGenerator(generator, context); }
public void MultipleParameterGeneratesCode() { // Arrange IContainer container = new Container (); container.Register<ISimpleObject, SimpleObject> (); container.Register<IShallowDependent, ShallowDependent> (); container.Register<IDeepDependent, DeepDependent> (); container.Register<IMultipleParameterObject, MultipleParameterObject> (); CodeGenerator codeGenerator = new CodeGenerator (); MemoryStream memoryStream = new MemoryStream (); // Act codeGenerator.WriteToStream(LanguageEnum.Csharp, container, memoryStream, "SomeNamespace", "TestContainer"); memoryStream.Position = 0; string charpString; using (StreamReader reader = new StreamReader(memoryStream)) { charpString = reader.ReadToEnd (); } TestContainer testContainer = new TestContainer (); IMultipleParameterObject result = testContainer.Resolve<IMultipleParameterObject> (); // Assert Assert.IsNotNull (result); Assert.IsNotNull (result.ShallowDependent); Assert.IsNotNull (result.SimpleObject); }
//--------------------------------------------------------------------- public static void ConstantQuery(OleDbConnection dbcon, CodeGenerator cg) { cg.ConstantList.Clear(); OleDbCommand cmd = new OleDbCommand("SELECT * FROM Constants ORDER BY Topic, ID", dbcon); OleDbDataReader dr = cmd.ExecuteReader(); while (dr.Read()) { Constant curConst = new Constant(); curConst.Name = dr["Name"].ToString(); curConst.Value = dr["Value"].ToString(); Int32 nTopic = Convert.ToInt32(dr["Topic"].ToString()); if (nTopic > 0) { curConst.Topic = cg.TopicList[nTopic - 1].Name.ToString(); } else { curConst.Topic = ""; } curConst.Description = dr["Description"].ToString(); cg.ConstantList.Add(curConst); //curConst.Print(); } dr.Close(); }
internal System.Runtime.Serialization.CreateXmlSerializableDelegate GenerateCreateXmlSerializableDelegate() { Type underlyingType = base.UnderlyingType; CodeGenerator generator = new CodeGenerator(); bool allowPrivateMemberAccess = this.RequiresMemberAccessForCreate(null); try { generator.BeginMethod("Create" + DataContract.GetClrTypeFullName(underlyingType), typeof(System.Runtime.Serialization.CreateXmlSerializableDelegate), allowPrivateMemberAccess); } catch (SecurityException exception) { if (!allowPrivateMemberAccess || !exception.PermissionType.Equals(typeof(ReflectionPermission))) { throw; } this.RequiresMemberAccessForCreate(exception); } if (underlyingType.IsValueType) { LocalBuilder localBuilder = generator.DeclareLocal(underlyingType, underlyingType.Name + "Value"); generator.Ldloca(localBuilder); generator.InitObj(underlyingType); generator.Ldloc(localBuilder); } else { generator.New(this.GetConstructor()); } generator.ConvertValue(base.UnderlyingType, Globals.TypeOfIXmlSerializable); generator.Ret(); return (System.Runtime.Serialization.CreateXmlSerializableDelegate) generator.EndMethod(); }
public SourceInfo(string source, string arg, MemberInfo memberInfo, Type type, CodeGenerator ilg) { this.Source = source; this.Arg = arg ?? source; this.MemberInfo = memberInfo; this.Type = type; this.ILG = ilg; }
//--------------------------------------------------------------------- public static void DatatypeQuery(OleDbConnection dbcon, CodeGenerator cg) { cg.DataTypeList.Clear(); OleDbCommand cmd = new OleDbCommand("SELECT * FROM DataTypes", dbcon); OleDbDataReader dr = cmd.ExecuteReader(); while (dr.Read()) { DataType curDatatype = new DataType(); curDatatype.ID = Convert.ToInt32(dr["ID"].ToString()); curDatatype.DataTypeName = dr["DataTypeName"].ToString(); curDatatype.CType = dr["CType"].ToString(); curDatatype.CTypeDef = dr["CTypeDef"].ToString(); curDatatype.CSType = dr["CSType"].ToString(); curDatatype.CSTypeDef = dr["CSTypeDef"].ToString(); curDatatype.VBType = dr["VBType"].ToString(); curDatatype.VBTypeDef = dr["VBTypeDef"].ToString(); curDatatype.PythonType = dr["PythonType"].ToString(); curDatatype.PythonTypeDef = dr["PythonTypeDef"].ToString(); cg.DataTypeList.Add(curDatatype); } dr.Close(); }
protected void Page_Load(object sender, EventArgs e) { try { Parameter = ProjectParameter.GetSettingsByProjectName(CurrentSession.UserCode, ProjectName); Generator = new CodeGenerator(Parameter); ColumnInfos = Generator.GetColumnsInfo(TableName, PrimaryKeyOverwrite); ReferFolder = Path.Combine(Server.MapPath(".."), "Manage\\Refer"); OutputFolder = Path.Combine(Server.MapPath(".."), string.Concat("Manage\\", CurrentSession.UserCode, "\\", TableName)); if (!System.IO.Directory.Exists(OutputFolder)) System.IO.Directory.CreateDirectory(OutputFolder); switch (type) { case 1: Search(); Callback(); Result(); Edit(); GetTogether.Mapping.MappingInfoCache.Caches.Clear(); if (!string.IsNullOrEmpty(Request["download"])) Compress(OutputFolder, string.Concat(OutputFolder, "-Management.zip")); break; default: break; } JsonSuccess(); } catch (Exception ex) { JsonError(ex.Message); } }
protected CSharpTarget(CodeGenerator gen, string language) : base(gen, language) { targetCharValueEscape[0] = "\\0"; targetCharValueEscape[0x0007] = "\\a"; targetCharValueEscape[0x000B] = "\\v"; }
protected void TestBuildCode(string classFileName, DocumentType contentType, string contentTypeName) { string expectedOutput; using (var goldReader = File.OpenText(@"..\..\TestFiles\" + classFileName + ".cs")) { expectedOutput = goldReader.ReadToEnd(); } var configuration = CodeGeneratorConfiguration.Create(); var typeConfig = configuration.Get(contentTypeName); typeConfig.BaseClass = "Umbraco.Core.Models.TypedModelBase"; typeConfig.Namespace = "Umbraco.CodeGen.Models"; configuration.TypeMappings.Add(new TypeMapping("Umbraco.Integer", "Int32")); OnConfiguring(configuration, contentTypeName); var sb = new StringBuilder(); var writer = new StringWriter(sb); var dataTypeProvider = new TestDataTypeProvider(); var generator = new CodeGenerator(typeConfig, dataTypeProvider, CreateGeneratorFactory()); generator.Generate(contentType, writer); writer.Flush(); Console.WriteLine(sb.ToString()); Assert.AreEqual(expectedOutput, sb.ToString()); }
internal CreateInstanceDelegate GenerateCreateInstanceDelegate(Type type, ConstructorInfo constructor) { bool allowPrivateMemberAccess = !IsTypeVisible(type) || ConstructorRequiresMemberAccess(constructor); this.ilg = new CodeGenerator(); try { this.ilg.BeginMethod("Create" + type.FullName, typeof(CreateInstanceDelegate), allowPrivateMemberAccess); } catch (SecurityException exception) { if (!allowPrivateMemberAccess || !exception.PermissionType.Equals(typeof(ReflectionPermission))) { throw; } if (DiagnosticUtility.ShouldTraceWarning) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityException(System.ServiceModel.SR.GetString("PartialTrustServiceCtorNotVisible", new object[] { type.FullName }))); } if (type.IsValueType) { LocalBuilder local = this.ilg.DeclareLocal(type, type.Name + "Instance"); this.ilg.LoadZeroValueIntoLocal(type, local); this.ilg.Load(local); } else { this.ilg.New(constructor); } this.ilg.ConvertValue(type, this.ilg.CurrentMethod.ReturnType); return (CreateInstanceDelegate) this.ilg.EndMethod(); }
private void CreateCodeFile(CodeGenerator generator) { using (IndentedTextWriter writer = CreateWriter(generator.Name + ".cs")) { generator.Write(writer, _Types); Close(writer); } }
static void Main(string[] args) { if (args.Length != 3) { PrintUsage(); return; } try { string destinationNamespace = args[0].Substring(3); string wsdlLocation = args[1].Substring(3); string outputFolder = args[2].Substring(3); ; CodeGenerator codeGen = new CodeGenerator(); CodeGenerationOptions options = new CodeGenerationOptions(); options.GenerateDataContracts = false; options.GenerateProperties = true; options.GenerateCollections = false; options.GenerateSeparateFiles = false; options.OverwriteExistingFiles = true; options.AdjustCasing = false; options.EnableDataBinding = false; options.GenerateOrderIdentifiers = true; options.GenerateTypedLists = true; options.ClrNamespace = destinationNamespace; options.OutputFileName = destinationNamespace + ".cs"; options.OutputLocation = outputFolder; options.ProjectDirectory = outputFolder; options.Language = CodeLanguage.CSharp; options.ConfigurationFile = "App.config"; options.EnableWsdlEndpoint = false; options.FormatSoapActions = false; options.GenerateAsyncCode = false; options.GenerateService = false; options.GenerateSvcFile = true; options.ConcurrencyMode = "Single"; options.InstanceContextMode = "PerCall"; options.MetadataLocation = wsdlLocation; options.MethodImplementation = MethodImplementation.NotImplementedException; options.UseSynchronizationContext = true; codeGen.GenerateCode(options); } catch (Exception e) { System.Console.WriteLine("Exception: " + e.Message); PrintUsage(); } }
public void Char_Default() { var codeGenerator = new CodeGenerator(); CodeGeneratorProperty generatedProperty = codeGenerator.GenerateFromType<Char>(); Assert.AreEqual(WidgetType.TextBox, generatedProperty.WidgetType); Assert.AreEqual(DatabaseColumnType.Char, generatedProperty.DatabaseColumn.Type); Assert.AreEqual(1, generatedProperty.DatabaseColumn.Size); Assert.AreEqual(MaskType.None, generatedProperty.Mask); }
private static void EmitCreateTargetInstance(Type targetType, TypeBuilder typeBuilder) { MethodBuilder methodBuilder = typeBuilder.DefineMethod(CreateTargetInstanceMethod, OverrideProtected, targetType, Type.EmptyTypes); var codeGenerator = new CodeGenerator(methodBuilder.GetILGenerator()); IEmitterType result = targetType.IsValueType ? EmitValueType(targetType, codeGenerator) : EmitRefType(targetType); EmitReturn.Return(result, targetType).Emit(codeGenerator); }
public DelegateManager() { basetype = typeof(Dispatcher); listtype = typeof(ArrayList); voidtype = typeof(void); typetype = typeof(Type); ptrtype = typeof(IntPtr); cache = new Hashtable(); codeGenerator = new CodeGenerator(); }
static void ApplyCodeGenerationProperties(CodeGenerator generator) { CodeGeneratorOptions options = generator.Options; System.CodeDom.Compiler.CodeGeneratorOptions cdo = new CodeDOMGeneratorUtility().CreateCodeGeneratorOptions; options.EmptyLinesBetweenMembers = cdo.BlankLinesBetweenMembers; options.BracesOnSameLine = CodeGenerationProperties.Get("StartBlockOnSameLine", true);; options.IndentString = cdo.IndentString; }
public IList<ITypeInfo> BuildTypeInfos() { var codeGenerator = new CodeGenerator(); var persistentTypes = XafTypesInfo.Instance.PersistentTypes; var codeInfos = persistentTypes.Select(codeGenerator.GetCode).Where(info => info != null).ToList(); var references = codeInfos.SelectMany(info => info.References).ToList(); RegisterReferences(references, typeof(ICommandChannel), typeof(CSharpCodeProvider)); var source = String.Join(Environment.NewLine, codeInfos.Select(info => info.Source).ToArray()); TypeGenerator.CreateDll(source, references.ToArray(), null); return codeInfos.Select(info => info.ViewTypeInfo).ToList(); }
public void String_Default() { var codeGenerator = new CodeGenerator(); CodeGeneratorProperty generatedProperty = codeGenerator.GenerateFromType<String>(); Assert.AreEqual(WidgetType.TextBox, generatedProperty.WidgetType); Assert.AreEqual(DatabaseColumnType.VarChar, generatedProperty.DatabaseColumn.Type); Assert.AreEqual(ValidationType.None, generatedProperty.Validation.Type); Assert.AreEqual(50, generatedProperty.DatabaseColumn.Size); Assert.AreEqual(MaskType.None, generatedProperty.Mask); }
public override CodeGenerator DecorateCodeGenerator(CodeGenerator incomingBuilder, CodeGeneratorContext context) { if (incomingBuilder is CodeGenTestCodeGenerator) { return incomingBuilder; } else { return new CodeGenTestCodeGenerator(context); } }
public LinqBuilder(CodeGenerator/*!*/ cg) { this.cg = cg; IPlace this_place = new IndexedPlace(PlaceHolder.Argument, 0); this.rtVariablesPlace = new Place(this_place, Fields.LinqContext_variables); this.scriptContextPlace = new Place(this_place, Fields.LinqContext_context); this.classContextPlace = new Place(this_place, Fields.LinqContext_typeHandle); this.selfPlace = new Place(this_place, Fields.LinqContext_outerType); }
public BitFlagsGenerator(int bitCount, CodeGenerator ilg, string localName) { _ilg = ilg; _bitCount = bitCount; int localCount = (bitCount + 7) / 8; _locals = new LocalBuilder[localCount]; for (int i = 0; i < _locals.Length; i++) { _locals[i] = ilg.DeclareLocal(typeof(byte), localName + i, (byte)0); } }
internal void Add(CodeGenerator.FrmBase frm, CodeGeneratorCommon.GeneratorsType pGeneratorsType) { if (!_GeneratorsList.ContainsKey(pGeneratorsType)) { _GeneratorsList.Add(pGeneratorsType, frm); if (_Metadata == null) _Metadata = frm.Metadata; else frm.Metadata = _Metadata; } }
public BitFlagsGenerator(int bitCount, CodeGenerator ilg, string localName) { this.ilg = ilg; this.bitCount = bitCount; int num = (bitCount + 7) / 8; this.locals = new LocalBuilder[num]; for (int i = 0; i < this.locals.Length; i++) { this.locals[i] = ilg.DeclareLocal(typeof(byte), localName + i, (byte) 0); } }
/// <summary> /// Initializes a new instance of the <see cref="SyntacticAnalyzer"/> class with the specified <see cref="LexicalAnalyzer"/>. /// </summary> /// <param name="lexical">The lexical analyzer.</param> public SyntacticAnalyzer(LexicalAnalyzer lexical) { if (lexical == null) { throw new ArgumentNullException(nameof(lexical)); } _lexical = lexical; _symbolTable = new VectorSymbolTable(); _codeGenerator = new CodeGenerator(); }
public static void Main() { CSharpCodeProvider cs = new CSharpCodeProvider(); CodeGenerator cg = new CodeGenerator(); using (StreamWriter sw=new StreamWriter("HelloWorld.cs",false)) { IndentedTextWriter tw = new IndentedTextWriter(sw, " "); cs.GenerateCodeFromCompileUnit(cg.GetCompierUnit(), tw, new CodeGeneratorOptions()); tw.Close(); } }
private void BeginMethod(CodeGenerator ilg, string methodName, Type delegateType, bool allowPrivateMemberAccess) { MethodInfo info = delegateType.GetMethod("Invoke"); ParameterInfo[] parameters = info.GetParameters(); Type[] parameterTypes = new Type[parameters.Length]; for (int i = 0; i < parameters.Length; i++) { parameterTypes[i] = parameters[i].ParameterType; } DynamicMethod dynamicMethod = new DynamicMethod(methodName, info.ReturnType, parameterTypes, typeof(JsonFormatWriterGenerator).Module, allowPrivateMemberAccess); ilg.BeginMethod(dynamicMethod, delegateType, methodName, parameterTypes, allowPrivateMemberAccess); }
private void InitializeCompiler() { _compiler = new MetaCodeCompiler(); CompilerService = CompilerService.Instance; MacroInterpreter = new MacroInterpreter(CompilerService); CodeInterpreter = new CodeInterpreter(CompilerService); CodeGenerator = new CodeGenerator(); SemanticParser = new SemanticParser(CompilerService); InitializeFunctions(); WindowTitle = "MetaCode IDE"; }
public void Int64_Default() { var codeGenerator = new CodeGenerator(); CodeGeneratorProperty generatedProperty = codeGenerator.GenerateFromType<Int64>(); Assert.AreEqual(WidgetType.TextBox, generatedProperty.WidgetType); Assert.AreEqual(DatabaseColumnType.BigInt, generatedProperty.DatabaseColumn.Type); Assert.AreEqual(8, generatedProperty.DatabaseColumn.Size); Assert.AreEqual(ValidationType.Range, generatedProperty.Validation.Type); Assert.AreEqual(Int64.MinValue, generatedProperty.Validation.MinimumValue); Assert.AreEqual(Int64.MaxValue, generatedProperty.Validation.MaximumValue); Assert.AreEqual(MaskType.Integer, generatedProperty.Mask); }
public async Task <int> CreateAsync(ProductionOrderModel model) { int result = 0; using (var transaction = DbContext.Database.BeginTransaction()) { try { int index = 0; foreach (var item in model.Details) { ProductionOrderModel productionOrder = new ProductionOrderModel() { OrderQuantity = item.Quantity, OrderNo = item.ProductionOrderNo, UnitCode = model.UnitCode, UnitId = model.UnitId, UnitName = model.UnitName, AccountId = model.AccountId, AccountUserName = model.AccountUserName, Active = model.Active, ArticleFabricEdge = model.ArticleFabricEdge, AutoIncreament = model.AutoIncreament, BuyerCode = model.BuyerCode, BuyerId = model.BuyerId, BuyerName = model.BuyerName, BuyerType = model.BuyerType, Code = model.Code, CreatedAgent = model.CreatedAgent, CreatedBy = model.CreatedBy, CreatedUtc = model.CreatedUtc, DeletedAgent = model.DeletedAgent, DeletedBy = model.DeletedBy, DeletedUtc = model.DeletedUtc, DeliveryDate = model.DeliveryDate, DesignCode = model.DesignCode, DesignMotiveCode = model.DesignMotiveCode, DesignMotiveID = model.DesignMotiveID, DesignMotiveName = model.DesignMotiveName, DesignNumber = model.DesignNumber, DistributedQuantity = model.DistributedQuantity, FinishTypeCode = model.FinishTypeCode, FinishTypeId = model.FinishTypeId, FinishTypeName = model.FinishTypeName, FinishTypeRemark = model.FinishTypeRemark, FinishWidth = model.FinishWidth, HandlingStandard = model.HandlingStandard, Id = model.Id, IsClosed = model.IsClosed, IsCompleted = model.IsCompleted, IsDeleted = model.IsDeleted, IsRequested = model.IsRequested, IsCalculated = model.IsCalculated, IsUsed = model.IsUsed, LastModifiedAgent = model.LastModifiedAgent, LastModifiedBy = model.LastModifiedBy, LastModifiedUtc = model.LastModifiedUtc, MaterialCode = model.MaterialCode, MaterialConstructionCode = model.MaterialConstructionCode, MaterialConstructionId = model.MaterialConstructionId, MaterialConstructionName = model.MaterialConstructionName, MaterialConstructionRemark = model.MaterialConstructionRemark, MaterialId = model.MaterialId, MaterialName = model.MaterialName, MaterialOrigin = model.MaterialOrigin, MaterialPrice = model.MaterialPrice, MaterialTags = model.MaterialTags, MaterialWidth = model.MaterialWidth, OrderTypeCode = model.OrderTypeCode, OrderTypeId = model.OrderTypeId, OrderTypeName = model.OrderTypeName, OrderTypeRemark = model.OrderTypeRemark, PackingInstruction = model.PackingInstruction, ProcessTypeCode = model.ProcessTypeCode, ProcessTypeId = model.ProcessTypeId, ProcessTypeName = model.ProcessTypeName, ProcessTypeRemark = model.ProcessTypeRemark, ProfileFirstName = model.ProfileFirstName, ProfileGender = model.ProfileGender, ProfileLastName = model.ProfileLastName, Remark = model.Remark, Run = model.Run, SalesContractId = model.SalesContractId, SalesContractNo = model.SalesContractNo, Sample = model.Sample, ShippingQuantityTolerance = model.ShippingQuantityTolerance, ShrinkageStandard = model.ShrinkageStandard, StandardTestCode = model.StandardTestCode, StandardTestId = model.StandardTestId, StandardTestName = model.StandardTestName, StandardTestRemark = model.StandardTestRemark, UId = model.UId, UomId = model.UomId, UomUnit = model.UomUnit, YarnMaterialCode = model.YarnMaterialCode, YarnMaterialId = model.YarnMaterialId, YarnMaterialName = model.YarnMaterialName, YarnMaterialRemark = model.YarnMaterialRemark, Details = new List <ProductionOrder_DetailModel> { item }, LampStandards = model.LampStandards != null?model.LampStandards.Select(x => new ProductionOrder_LampStandardModel() { Active = x.Active, Code = x.Code, CreatedAgent = x.CreatedAgent, CreatedBy = x.CreatedBy, CreatedUtc = x.CreatedUtc, DeletedAgent = x.DeletedAgent, DeletedBy = x.DeletedBy, DeletedUtc = x.DeletedUtc, Description = x.Description, Id = x.Id, IsDeleted = x.IsDeleted, LampStandardId = x.LampStandardId, LastModifiedAgent = x.LastModifiedAgent, LastModifiedBy = x.LastModifiedBy, LastModifiedUtc = x.LastModifiedUtc, Name = x.Name, ProductionOrderModel = x.ProductionOrderModel, UId = x.UId }).ToArray() : new ProductionOrder_LampStandardModel[0], RunWidths = model.RunWidths != null?model.RunWidths.Select(x => new ProductionOrder_RunWidthModel() { Value = x.Value, Active = x.Active, CreatedAgent = x.CreatedAgent, CreatedBy = x.CreatedBy, CreatedUtc = x.CreatedUtc, IsDeleted = x.IsDeleted, DeletedAgent = x.DeletedAgent, DeletedBy = x.DeletedBy, DeletedUtc = x.DeletedUtc, Id = x.Id, LastModifiedAgent = x.LastModifiedAgent, LastModifiedBy = x.LastModifiedBy, LastModifiedUtc = x.LastModifiedUtc, ProductionOrderModel = x.ProductionOrderModel, UId = x.UId }).ToArray() : new ProductionOrder_RunWidthModel[0] }; do { productionOrder.Code = CodeGenerator.Generate(); }while (DbSet.Any(d => d.Code.Equals(productionOrder.Code))); productionOrderLogic.Create(productionOrder); index++; } FinishingPrintingSalesContractModel dataFPSalesContract = await finishingPrintingSalesContractLogic.ReadByIdAsync(model.SalesContractId); if (dataFPSalesContract != null) { dataFPSalesContract.RemainingQuantity = dataFPSalesContract.RemainingQuantity - model.OrderQuantity; this.finishingPrintingSalesContractLogic.UpdateAsync(dataFPSalesContract.Id, dataFPSalesContract); } result = await DbContext.SaveChangesAsync(); transaction.Commit(); } catch (Exception e) { transaction.Rollback(); throw new Exception(e.Message); } } return(result); }
internal override void Emit(CodeGenerator cg) { cg.Builder.DefineInitialHiddenSequencePoint(); // first brace sequence point var body = cg.Routine.Syntax.BodySpanOrInvalid(); if (body.IsValid && cg.IsDebug) { cg.EmitSequencePoint(new Span(body.Start, 1)); cg.EmitOpCode(ILOpCode.Nop); } // if (cg.IsDebug) { if (cg.Routine.IsStatic) { // Debug.Assert(<context> != null); cg.EmitDebugAssertNotNull(cg.ContextPlaceOpt, "Context cannot be null."); } // TODO: emit parameters checks } // var locals = cg.Routine.LocalsTable; // in case of script, declare the script, functions and types if (cg.Routine is SourceGlobalMethodSymbol) { // <ctx>.OnInclude<TScript>() cg.EmitLoadContext(); cg.EmitCall(ILOpCode.Callvirt, cg.CoreMethods.Context.OnInclude_TScript.Symbol.Construct(cg.Routine.ContainingType)); // <ctx>.DeclareFunction() cg.ContainingFile.Functions .Where(f => !f.IsConditional) .ForEach(cg.EmitDeclareFunction); // <ctx>.DeclareType() cg.ContainingFile.ContainedTypes .Where(t => !t.IsConditional && !t.IsAnonymousType) // non conditional declaration within this file .ForEach(cg.EmitDeclareType); } else { //If it has unoptimized locals and they're not initilized externally -> need to initialize them if (cg.HasUnoptimizedLocals && !cg.InitializedLocals) { // <locals> = new PhpArray(HINTCOUNT) cg.LocalsPlaceOpt.EmitStorePrepare(cg.Builder); cg.Builder.EmitIntConstant(locals.Count); // HINTCOUNT cg.EmitCall(ILOpCode.Newobj, cg.CoreMethods.Ctors.PhpArray_int); cg.LocalsPlaceOpt.EmitStore(cg.Builder); } } if (!cg.InitializedLocals) { // variables/parameters initialization foreach (var loc in locals.Variables) { loc.EmitInit(cg); } } // if generator method: emit switch table for continuation & change state to -1 (running) if (cg.Routine.IsGeneratorMethod()) { EmitStateMachineMethodStart(cg); } // base.Emit(cg); }
internal override void Emit(CodeGenerator cg) { cg.Builder.DefineInitialHiddenSequencePoint(); // if (cg.IsDebug) { if (cg.Routine.IsStatic) { // Debug.Assert(<context> != null); cg.EmitDebugAssertNotNull(cg.ContextPlaceOpt, "Context cannot be null."); } // TODO: emit parameters checks } // in case of script, declare the script, functions and types if (cg.Routine is SourceGlobalMethodSymbol) { // <ctx>.OnInclude<TScript>() cg.EmitLoadContext(); cg.EmitCall(ILOpCode.Callvirt, cg.CoreMethods.Context.OnInclude_TScript.Symbol.Construct(cg.Routine.ContainingType)); } // var locals = cg.Routine.LocalsTable; if (!cg.InitializedLocals) { // If it has unoptimized locals and they're not initilized externally -> need to initialize them if (cg.HasUnoptimizedLocals) { // <locals> = new PhpArray(HINTCOUNT) cg.LocalsPlaceOpt.EmitStorePrepare(cg.Builder); cg.Builder.EmitIntConstant(locals.Count); // HINTCOUNT cg.EmitCall(ILOpCode.Newobj, cg.CoreMethods.Ctors.PhpArray_int); cg.LocalsPlaceOpt.EmitStore(cg.Builder); } } // variables/parameters initialization foreach (var loc in locals.Variables) { loc.EmitInit(cg); } // emit dummy locals showing indirect (unoptimized) locals in debugger's Watch and Locals window if (cg.HasUnoptimizedLocals && cg.EmitPdbSequencePoints && cg.IsDebug && cg.CoreTypes.IndirectLocal.Symbol != null) { EmitIndirectLocalsDebugWatch(cg); } // remember array of arguments: if ((cg.Routine.Flags & FlowAnalysis.RoutineFlags.UsesArgs) != 0) { // <>args = cg.Emit_ArgsArray() var arrtype = cg.Emit_ArgsArray(cg.CoreTypes.PhpValue); cg.FunctionArgsArray = cg.GetTemporaryLocal(arrtype); cg.Builder.EmitLocalStore(cg.FunctionArgsArray); } // first brace sequence point var body = cg.Routine.Syntax.BodySpanOrInvalid(); if (body.IsValid && cg.IsDebug) { cg.EmitSequencePoint(new Span(body.Start, 1)); } // if generator method: emit switch table for continuation & change state to -1 (running) if (cg.Routine.IsGeneratorMethod()) { EmitStateMachineMethodStart(cg); } // base.Emit(cg); }
/// <summary> /// Emit body of enumeration of app-wide global constants. /// </summary> internal void CreateEnumerateConstantsSymbol(DiagnosticBag diagnostic) { var method = this.ScriptType.EnumerateConstantsSymbol; var consts = this.Compilation.GlobalSemantics.GetExportedConstants(); // void (Action<string, RuntimeMethodHandle> callback) var body = MethodGenerator.GenerateMethodBody(this, method, (il) => { var cg = new CodeGenerator(il, this, diagnostic, this.Compilation.Options.OptimizationLevel, false, this.ScriptType, null, null); // interface IConstantsComposition var constantscomposition = method.Parameters[0].Type; Debug.Assert(constantscomposition.Name == "IConstantsComposition"); // Define(string, ...) var define_xxx = constantscomposition .GetMembers("Define") .OfType <MethodSymbol>() .Where(m => m.ParameterCount == 2) .ToArray(); var define_string = define_xxx.Single(m => m.Parameters[1].Type.SpecialType == SpecialType.System_String); var define_long = define_xxx.Single(m => m.Parameters[1].Type.SpecialType == SpecialType.System_Int64); var define_double = define_xxx.Single(m => m.Parameters[1].Type.SpecialType == SpecialType.System_Double); var define_func = define_xxx.Single(m => m.Parameters[1].Type.Name == "Func"); // Func<PhpValue> var define_value = define_xxx.Single(m => m.Parameters[1].Type == cg.CoreTypes.PhpValue); foreach (var c in consts.OfType <Symbol>()) { // composer.Define(c.Name, c.Value) il.EmitLoadArgumentOpcode(0); // string : name il.EmitStringConstant(c.MetadataName); if (c is FieldSymbol fld) { // PhpValue : value TypeSymbol consttype; var constvalue = fld.GetConstantValue(false); if (constvalue != null) { consttype = cg.EmitLoadConstant(constvalue.Value, cg.CoreTypes.PhpValue); } else { consttype = new FieldPlace(null, fld, this).EmitLoad(il); } // Define(...) if (consttype.SpecialType == SpecialType.System_Int32) { // i4 -> i8 il.EmitOpCode(ILOpCode.Conv_i8); consttype = cg.CoreTypes.Long; } MethodSymbol define_method = null; if (consttype.SpecialType == SpecialType.System_String) { define_method = define_string; } else if (consttype.SpecialType == SpecialType.System_Int64) { define_method = define_long; } else if (consttype.SpecialType == SpecialType.System_Double) { define_method = define_double; } else { cg.EmitConvertToPhpValue(consttype, 0); define_method = define_value; } il.EmitCall(this, diagnostic, ILOpCode.Callvirt, define_method); } else if (c is PropertySymbol prop) { MethodSymbol getter_func; // Func<PhpValue> if (prop.Type == cg.CoreTypes.PhpValue) { getter_func = prop.GetMethod; } else { // static PhpValue get_XXX => get_prop(); getter_func = new SynthesizedMethodSymbol(ScriptType, "get_" + prop.Name, true, false, cg.CoreTypes.PhpValue, Accessibility.Internal); SynthesizedManager.AddMethod(ScriptType, getter_func); SetMethodBody(getter_func, MethodGenerator.GenerateMethodBody(this, getter_func, _il => { var _cg = new CodeGenerator(_il, this, diagnostic, this.Compilation.Options.OptimizationLevel, false, ScriptType, null, null); _cg.EmitRet(_cg.EmitConvertToPhpValue(_cg.EmitForwardCall(prop.GetMethod, getter_func, callvirt: false), 0)); }, null, diagnostic, false)); } // new Func<PhpValue>(object @object = null, IntPtr method = getter_func) cg.Builder.EmitNullConstant(); // null cg.EmitOpCode(ILOpCode.Ldftn); // method cg.EmitSymbolToken(getter_func, null); cg.EmitCall(ILOpCode.Newobj, Compilation.GetWellKnownType(WellKnownType.System_Func_T).Construct(cg.CoreTypes.PhpValue).InstanceConstructors[0]); // il.EmitCall(this, diagnostic, ILOpCode.Callvirt, define_func); } else { throw ExceptionUtilities.UnexpectedValue(c); } } // il.EmitRet(true); }, null, diagnostic, false); SetMethodBody(method, body); }
/// <summary> /// Emits code to prepare an evaluation stack for storing a value into a variable. /// Supports operators chaining. Store is finished by calling <see cref="EmitAssign"/>. /// </summary> /// <param name="node">Instance.</param> /// <param name="codeGenerator"></param> private PhpTypeCode EmitNodeWrite(ItemUse /*!*/ node, CodeGenerator codeGenerator) { ChainBuilder chain = codeGenerator.ChainBuilder; if (chain.IsArrayItem) { // 3: a_[x]_[v] Debug.Assert(node.IsMemberOf == null); return(chain.EmitEnsureItem(node.Array, node.Index, true)); } // 1, 2, 4, 5, 6, 7 if (chain.IsMember) { // 4, 5 if (node.IsMemberOf != null) { // 5: ...->a[]->... // Store isMemberOf for lazy emit chain.SetObjectForLazyEmit(node); chain.IsArrayItem = true; chain.IsLastMember = false; } else { // 4: a_[x]_->c->..., a[x]_[x]_->c->... chain.IsArrayItem = true; chain.IsLastMember = true; } PhpTypeCode result = chain.EmitEnsureItem(node.Array, node.Index, false); chain.IsArrayItem = false; return(result); } // 1, 2, 6, 7 if (node.IsMemberOf != null) { // 6, 7: ...->a[x]_[x]_ chain.Create(); chain.Begin(); // Store isMemberOf for lazy emit chain.SetObjectForLazyEmit(node); chain.IsArrayItem = true; chain.IsLastMember = false; chain.Lengthen(); // for own [] node.Array.Emit(codeGenerator); indexTypeCode = codeGenerator.EmitArrayKey(chain, node.Index); // Note that EmitAssign will finish the work (SetArrayItem or PhpArray.Add) return(PhpTypeCode.Unknown); } // 1, 2 Debug.Assert(node.IsMemberOf == null); if (node.Array is ItemUse || node.Array is DirectStFldUse || node.Array is IndirectStFldUse /* ??? */) { // 2: a[]_[]_ chain.Create(); chain.Begin(); chain.IsArrayItem = true; chain.IsLastMember = true; node.Array.Emit(codeGenerator); indexTypeCode = codeGenerator.EmitArrayKey(chain, node.Index); // Note that further work will be done by EmitAssign (SetArrayItem or PhpArray.Add) return(PhpTypeCode.Unknown); } // 1: a_[x]_ // Do nothing now, let the work be done in EmitAssign() return(PhpTypeCode.Unknown); }
/// <summary> /// Emits code to load <see cref="PhpRuntimeChain"/> onto an evaluation stack. Supports operators chaining. /// </summary> /// <param name="node">Instance.</param> /// <param name="codeGenerator"></param> private PhpTypeCode EmitNodeReadUnknown(ItemUse /*!*/ node, CodeGenerator codeGenerator) { ChainBuilder chain = codeGenerator.ChainBuilder; PhpTypeCode result = PhpTypeCode.PhpRuntimeChain; if (chain.IsArrayItem) { // 3: a_[x]_[x] chain.Lengthen(); // for [] chain.EmitRTChainAddItem(node); return(result); } // 1,2,4,5,6,7 if (chain.IsMember) { // 4, 5 if (node.IsMemberOf != null) { // 5: ...->a[]->... // Lengthen chain for isMemberOf chain.Lengthen(); // for hop over -> PhpTypeCode res = node.IsMemberOf.Emit(codeGenerator); if (res != PhpTypeCode.PhpRuntimeChain) { codeGenerator.EmitBoxing(res); chain.EmitCreateRTChain(); } // Lengthen chain for own [] chain.Lengthen(); chain.IsArrayItem = true; chain.IsLastMember = false; chain.EmitRTChainAddItem(node); chain.IsArrayItem = false; return(result); } // 4: a[x]->... // Lengthen chain for itself chain.Lengthen(); // for own [] chain.IsArrayItem = true; chain.IsLastMember = true; chain.EmitRTChainAddItem(node); chain.IsArrayItem = false; return(result); } // 1, 2, 6, 7 if (node.IsMemberOf != null) { // 6 , 7: ...->a[]_[]_ , ...->a_[]_ bool quiet_read = chain.QuietRead; chain.Create(); chain.Begin(); chain.QuietRead = quiet_read; chain.Lengthen(); // for hop over -> PhpTypeCode res = node.IsMemberOf.Emit(codeGenerator); if (res != PhpTypeCode.PhpRuntimeChain) { codeGenerator.EmitBoxing(res); chain.EmitCreateRTChain(); } chain.IsArrayItem = true; chain.IsLastMember = false; chain.EmitRTChainAddItem(node); chain.IsArrayItem = false; chain.End(); return(result); } // 1, 2 if (node.Array is ItemUse || node.Array is DirectStFldUse || node.Array is IndirectStFldUse /* ??? */) { // 2: a[]_[]_ bool quiet_read = chain.QuietRead; chain.Create(); chain.Begin(); chain.QuietRead = quiet_read; chain.IsArrayItem = true; chain.IsLastMember = true; chain.EmitRTChainAddItem(node); chain.IsArrayItem = false; chain.End(); return(result); } // 1: a_[x]_ chain.IsArrayItem = true; chain.IsLastMember = true; chain.EmitRTChainAddItem(node); chain.IsArrayItem = false; return(result); }
public override void Generate(CodeGenerator cg) { varInfo.Create(cg); expr.Generate(cg); cg.generator.Emit(OpCodes.Stsfld, varInfo.fieldBuilder); }
void EmitCatchBlock(CodeGenerator cg, CatchBlock catchBlock) { Debug.Assert(catchBlock.Variable.Variable != null); var il = cg.Builder; TypeSymbol extype; il.AdjustStack(1); // Account for exception on the stack. if (catchBlock.TypeRef.ResolvedType.IsErrorTypeOrNull() || !catchBlock.TypeRef.ResolvedType.IsOfType(cg.CoreTypes.Exception)) { // Template: catch when il.OpenLocalScope(ScopeType.Filter); // STACK : object if (catchBlock.TypeRef.ResolvedType.IsErrorTypeOrNull()) { extype = cg.CoreTypes.Object.Symbol; // Template: filter(Operators.IsInstanceOf(<stack>, type)) catchBlock.TypeRef.EmitLoadTypeInfo(cg, false); cg.EmitCall(ILOpCode.Call, cg.CoreMethods.Operators.IsInstanceOf_Object_PhpTypeInfo) .Expect(SpecialType.System_Boolean); } else { extype = catchBlock.TypeRef.ResolvedType; // Template: filter (<stack> is Interface) il.EmitOpCode(ILOpCode.Isinst); cg.EmitSymbolToken(extype, null); il.EmitNullConstant(); il.EmitOpCode(ILOpCode.Cgt_un); // value > null : bool } // STACK : i4 ? handle : continue il.MarkFilterConditionEnd(); // STACK : object cg.EmitCastClass(cg.CoreTypes.Exception); // has to be casted to System.Exception in order to generate valid IL cg.EmitCastClass(extype); } else { // Template: catch (TypeRef) extype = catchBlock.TypeRef.ResolvedType; il.OpenLocalScope(ScopeType.Catch, cg.Module.Translate(extype, null, cg.Diagnostics)); } // STACK : extype // <tmp> = <ex> cg.EmitSequencePoint(catchBlock.Variable.PhpSyntax); var tmploc = cg.GetTemporaryLocal(extype); il.EmitLocalStore(tmploc); var varplace = catchBlock.Variable.BindPlace(cg); Debug.Assert(varplace != null); // $x = <tmp> varplace.EmitStorePrepare(cg); il.EmitLocalLoad(tmploc); varplace.EmitStore(cg, (TypeSymbol)tmploc.Type); // cg.ReturnTemporaryLocal(tmploc); tmploc = null; // cg.GenerateScope(catchBlock, NextBlock.Ordinal); // il.CloseLocalScope(); }
/// <summary> /// Generates or enqueues next blocks to the worklist. /// </summary> internal abstract void Generate(CodeGenerator cg);
void EmitTryStatement(CodeGenerator cg, bool emitCatchesOnly = false) { // Stack must be empty at beginning of try block. cg.Builder.AssertStackEmpty(); // IL requires catches and finally block to be distinct try // blocks so if the source contained both a catch and // a finally, nested scopes are emitted. bool emitNestedScopes = (!emitCatchesOnly && //(_catchBlocks.Length != 0) && (_finallyBlock != null)); cg.Builder.OpenLocalScope(ScopeType.TryCatchFinally); cg.Builder.OpenLocalScope(ScopeType.Try); // IL requires catches and finally block to be distinct try // blocks so if the source contained both a catch and // a finally, nested scopes are emitted. //_tryNestingLevel++; if (emitNestedScopes) { EmitTryStatement(cg, emitCatchesOnly: true); } else { cg.GenerateScope(_body, (_finallyBlock ?? NextBlock).Ordinal); } //_tryNestingLevel--; // Close the Try scope cg.Builder.CloseLocalScope(); if (!emitNestedScopes) { EmitScriptDiedBlock(cg); // foreach (var catchBlock in _catchBlocks) { EmitCatchBlock(cg, catchBlock); } } if (!emitCatchesOnly && _finallyBlock != null) { cg.Builder.OpenLocalScope(ScopeType.Finally); cg.GenerateScope(_finallyBlock, NextBlock.Ordinal); // close Finally scope cg.Builder.CloseLocalScope(); } // close the whole try statement scope cg.Builder.CloseLocalScope(); if (!emitCatchesOnly) { // cg.Scope.ContinueWith(NextBlock); } }
public override void InsertCompletionText(CompletionListWindow window, ref KeyActions ka, Gdk.Key closeChar, char keyChar, Gdk.ModifierType modifier) { var editor = ext.TextEditorData; var generator = CodeGenerator.CreateGenerator(ext.Document); bool isExplicit = false; if (member.DeclaringTypeDefinition.Kind == TypeKind.Interface) { foreach (var m in type.Members) { if (m.Name == member.Name && !m.ReturnType.Equals(member.ReturnType)) { isExplicit = true; break; } } } var resolvedType = type.Resolve(ext.Project).GetDefinition(); if (ext.Project != null) { generator.PolicyParent = ext.Project.Policies; } var result = generator.CreateMemberImplementation(resolvedType, type, member, isExplicit); string sb = result.Code.TrimStart(); int trimStart = result.Code.Length - sb.Length; sb = sb.TrimEnd(); var lastRegion = result.BodyRegions.LastOrDefault(); var region = lastRegion == null? null : new CodeGeneratorBodyRegion(lastRegion.StartOffset - trimStart, lastRegion.EndOffset - trimStart); int targetCaretPosition; int selectionEndPosition = -1; if (region != null && region.IsValid) { targetCaretPosition = declarationBegin + region.StartOffset; if (region.Length > 0) { if (GenerateBody) { selectionEndPosition = declarationBegin + region.EndOffset; } else { //FIXME: if there are multiple regions, remove all of them sb = sb.Substring(0, region.StartOffset) + sb.Substring(region.EndOffset); } } } else { targetCaretPosition = declarationBegin + sb.Length; } editor.Replace(declarationBegin, editor.Caret.Offset - declarationBegin, sb); if (selectionEndPosition > 0) { editor.Caret.Offset = selectionEndPosition; editor.SetSelection(targetCaretPosition, selectionEndPosition); } else { editor.Caret.Offset = targetCaretPosition; } }
/// <summary> /// Ensures no component of the namespace is a C# keyword. /// </summary> /// <param name="p"></param> /// <returns></returns> private string SanitizeNamespace(string nmspace, CodeGenerator gen) { return(string.Join(".", nmspace.Split('.') .Select(n => gen.EscapeKeywordName(n)))); }
private void InternalLoad(Type elementType, bool asAddress = false) { Match match = s_regex.Match(Arg); if (match.Success) { object varA = ILG.GetVariable(match.Groups["a"].Value); Type varType = ILG.GetVariableType(varA); object varIA = ILG.GetVariable(match.Groups["ia"].Value); if (varType.IsArray) { ILG.Load(varA); ILG.Load(varIA); Type eType = varType.GetElementType(); if (CodeGenerator.IsNullableGenericType(eType)) { ILG.Ldelema(eType); ConvertNullableValue(eType, elementType); } else { if (eType.IsValueType) { ILG.Ldelema(eType); if (!asAddress) { ILG.Ldobj(eType); } } else { ILG.Ldelem(eType); } if (elementType != null) { ILG.ConvertValue(eType, elementType); } } } else { ILG.Load(varA); ILG.Load(varIA); MethodInfo get_Item = varType.GetMethod( "get_Item", CodeGenerator.InstanceBindingFlags, new Type[] { typeof(Int32) } ); if (get_Item == null && typeof(IList).IsAssignableFrom(varType)) { get_Item = s_iListGetItemMethod.Value; } Debug.Assert(get_Item != null); ILG.Call(get_Item); Type eType = get_Item.ReturnType; if (CodeGenerator.IsNullableGenericType(eType)) { LocalBuilder localTmp = ILG.GetTempLocal(eType); ILG.Stloc(localTmp); ILG.Ldloca(localTmp); ConvertNullableValue(eType, elementType); } else if ((elementType != null) && !(eType.IsAssignableFrom(elementType) || elementType.IsAssignableFrom(eType))) { throw new CodeGeneratorConversionException(eType, elementType, asAddress, "IsNotAssignableFrom"); } else { Convert(eType, elementType, asAddress); } } } else if (Source == "null") { ILG.Load(null); } else { object var; Type varType; if (Arg.StartsWith("o.@", StringComparison.Ordinal) || MemberInfo != null) { var = ILG.GetVariable(Arg.StartsWith("o.@", StringComparison.Ordinal) ? "o" : Arg); varType = ILG.GetVariableType(var); if (varType.IsValueType) { ILG.LoadAddress(var); } else { ILG.Load(var); } } else { var = ILG.GetVariable(Arg); varType = ILG.GetVariableType(var); if (CodeGenerator.IsNullableGenericType(varType) && varType.GetGenericArguments()[0] == elementType) { ILG.LoadAddress(var); ConvertNullableValue(varType, elementType); } else { if (asAddress) { ILG.LoadAddress(var); } else { ILG.Load(var); } } } if (MemberInfo != null) { Type memberType = (MemberInfo is FieldInfo) ? ((FieldInfo)MemberInfo).FieldType : ((PropertyInfo)MemberInfo).PropertyType; if (CodeGenerator.IsNullableGenericType(memberType)) { ILG.LoadMemberAddress(MemberInfo); ConvertNullableValue(memberType, elementType); } else { ILG.LoadMember(MemberInfo); Convert(memberType, elementType, asAddress); } } else { match = s_regex2.Match(Source); if (match.Success) { Debug.Assert(match.Groups["arg"].Value == Arg); Debug.Assert(match.Groups["cast"].Value == CodeIdentifier.GetCSharpName(Type)); if (asAddress) { ILG.ConvertAddress(varType, Type); } else { ILG.ConvertValue(varType, Type); } varType = Type; } Convert(varType, elementType, asAddress); } } }
public override string GenerateCode(Object obj) { if (obj is INode) { //Ensure we are targeting graph so the generated code will using 'this' keyword obj = (obj as INode).GetNodeOwner() as Object; } Init(); if (!CodeGenerator.HasUserObject(this)) { foreach (var init in initializers) { if (init.value.CanSafeGetValue()) { var field = instance.GetType().GetField(init.name); if (field != null) { field.SetValueOptimized(instance, init.value.Get()); } } } CodeGenerator.RegisterUserObject(new VariableData(Name, instance.GetType(), instance) { modifier = FieldModifier.PrivateModifier, }, this); } var variable = CodeGenerator.GetUserObject <VariableData>(this); string generatedInstanceName = CodeGenerator.AddVariable(variable); //Initialize instance System.Text.StringBuilder builder = new System.Text.StringBuilder(); foreach (var init in initializers) { if (init.value.isAssigned && !init.value.CanSafeGetValue()) //Ensure we are only set the dynamic value { builder.Append(generatedInstanceName.Access(init.name).Set(init.value.ToCode()).AddLineInFirst()); } } string initCode = builder.ToString(); if (instance is IFlowNode || instance is IStateNode && !storeResult.isAssigned) { return(CodeGenerator.GenerateFlowStatement( initCode, generatedInstanceName.InvokeCode(nameof(IFlowNode.Execute), obj.ToCode()) )); } else if (instance is IStateNode) { return(CodeGenerator.GenerateFlowStatement( initCode, CodeGenerator.GenerateSetCode( storeResult, generatedInstanceName.InvokeCode(nameof(IStateNode.Execute), obj.ToCode()).RemoveSemicolon()) )); } else if (instance is ICoroutineNode || instance is IStateCoroutineNode && !storeResult.isAssigned) { CodeGenerator.RegisterCoroutineEvent( instance, () => generatedInstanceName.InvokeCode(nameof(ICoroutineNode.Execute), obj.ToCode()).RemoveLast(), true); return(CodeGenerator.GenerateFlowStatement( initCode, CodeGenerator.WaitEvent(instance) )); } else if (instance is IStateCoroutineNode) { CodeGenerator.RegisterCoroutineEvent( instance, () => generatedInstanceName.InvokeCode(nameof(IStateCoroutineNode.Execute), obj.ToCode()).RemoveLast(), true); return(CodeGenerator.GenerateFlowStatement( initCode, CodeGenerator.WaitEvent(instance), CodeGenerator.GenerateSetCode(storeResult, CodeGenerator.CompareEventState(instance, true)) )); } return(null); }
public override async Task <ResourceInfo> CreateEmptyResource(string absFolder, string rootFolder, IResourceCreateData createData) { await EngineNS.Thread.AsyncDummyClass.DummyFunc(); var result = new ParticleResourceInfo(); var data = createData as ParticleCreateData; //result.CenterDataTypeName = data.CenterDataTypeName; var reName = EngineNS.CEngine.Instance.FileManager._GetRelativePathFromAbsPath(absFolder + "/" + data.ResourceName, rootFolder); reName += EngineNS.CEngineDesc.MacrossExtension; result.ResourceName = EngineNS.RName.GetRName(reName, data.RNameType); result.BaseTypeIsMacross = data.IsMacrossType; if (result.BaseTypeIsMacross) { result.BaseTypeSaveName = data.ClassType.FullName; var baseResInfo = await GetBaseMacrossResourceInfo(this); if (baseResInfo != null) { ReferenceRNameList.Add(baseResInfo.ResourceName); } } else { result.BaseTypeSaveName = EngineNS.Rtti.RttiHelper.GetTypeSaveString(data.ClassType); } result.ResourceType = EngineNS.Editor.Editor_RNameTypeAttribute.Macross; //拷贝模板 if (string.IsNullOrEmpty(data.TemplateName) == false) { string newfolder = result.ResourceName.Address; string tempfolder = RName.GetRName(data.TemplateName).Address; EngineNS.CEngine.Instance.FileManager.CreateDirectory(newfolder); EngineNS.CEngine.Instance.FileManager.CopyDirectory(tempfolder, newfolder); //EngineNS.CEngine.Instance.FileManager.DeleteFile(newfolder + "/particle1_Client.cs"); //string newcsname = newfolder + "/" + data.ResourceName + "_Client.cs"; //if (EngineNS.CEngine.Instance.FileManager.FileExists(newcsname)) //{ // EngineNS.CEngine.Instance.FileManager.DeleteFile(newcsname); //} var csfiles = EngineNS.CEngine.Instance.FileManager.GetFiles(newfolder, "*.cs", System.IO.SearchOption.AllDirectories); if (csfiles != null && csfiles.Count != 0) { for (int i = 0; i < csfiles.Count; i++) { if (EngineNS.CEngine.Instance.FileManager.FileExists(csfiles[i])) { EngineNS.CEngine.Instance.FileManager.DeleteFile(csfiles[i]); } } } } // 创建时走一遍编译,保证当前Macross能够取到this类型 var csType = ECSType.Client; var codeGenerator = new CodeGenerator(); var ctrl = new ParticleMacrossLinkControl(); ctrl.CurrentResourceInfo = result; ctrl.CSType = csType; var codeStr = await codeGenerator.GenerateCode(result, ctrl); if (!EngineNS.CEngine.Instance.FileManager.DirectoryExists(result.ResourceName.Address)) { EngineNS.CEngine.Instance.FileManager.CreateDirectory(result.ResourceName.Address); } var codeFile = $"{result.ResourceName.Address}/{result.ResourceName.PureName()}_{csType.ToString()}.cs"; using (var fs = new System.IO.FileStream(codeFile, System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.ReadWrite)) { fs.Write(System.Text.Encoding.Default.GetBytes(codeStr), 0, Encoding.Default.GetByteCount(codeStr)); } await codeGenerator.GenerateAndSaveMacrossCollector(csType); var files = codeGenerator.CollectionMacrossProjectFiles(csType); codeGenerator.GenerateMacrossProject(files.ToArray(), csType); EditorCommon.Program.BuildGameDll(true); return(result); }
public async Task <Models.File> SavePrivateFileAsync(IFormFile file, string desPath) { try { var fileInfo = new Models.File() { Id = 0, Name = file.FileName, Path = Config.privateFilePath + desPath + DateTime.Now.ToString("yyyyMMddHHmmss") + CodeGenerator.GetCode(5) + Path.GetExtension(file.FileName), Size = file.Length }; using (var stream = System.IO.File.Create(fileInfo.Path)) { await file.CopyToAsync(stream); } await dbContext.Files.AddAsync(fileInfo); await dbContext.SaveChangesAsync(); if (file.ContentType.ToLower().Contains("pdf")) { _ = this.GeneratePreviewPdf(fileInfo); } else if (file.ContentType.ToLower().Contains("video")) { _ = this.GeneratePreviewVideo(fileInfo); } else if (fileInfo.Name.ToLower().Contains("pptx")) { _ = this.GeneratePreviewPPTX(fileInfo); } else if (fileInfo.Name.ToLower().Contains("ppt")) { _ = this.GeneratePreviewPPT(fileInfo); } else if (fileInfo.Name.ToLower().Contains("doc")) { _ = this.GeneratePreviewWord(fileInfo); } return(fileInfo); } catch (Exception e) { logger.LogError(e.Message); throw new Exception("Server Failed to Save File"); } }
/// <summary> /// Emits code to load variable onto the evaluation stack. Supports operators chaining. /// </summary> /// <param name="node">Instance.</param> /// <param name="codeGenerator">A geenrator.</param> /// <param name="itemGetterKind">Whether to load for "get", "isset", or "empty".</param> private PhpTypeCode EmitNodeRead(ItemUse /*!*/ node, CodeGenerator /*!*/ codeGenerator, Operators.GetItemKinds itemGetterKind) { var chain = codeGenerator.ChainBuilder; var itemuse = (ItemUse)node; PhpTypeCode result; if (chain.IsArrayItem) { // we are in the itemuse.Array subchain // // 3: a_[x]_[x] chain.Lengthen(); // for [] result = chain.EmitGetItem(itemuse.Array, itemuse.Index, itemGetterKind); return(result); } // 1,2,4,5,6,7 if (chain.IsMember) { // we are in the field chain // // 4, 5 if (node.IsMemberOf != null) { // we are in the middle of the field chain // // 5: ...->a[]->... // Lengthen chain for isMemberOf chain.Lengthen(); // for hop over -> node.IsMemberOf.Emit(codeGenerator); // Lengthen chain for own [] chain.Lengthen(); chain.IsArrayItem = true; chain.IsLastMember = false; result = chain.EmitGetItem(itemuse.Array, itemuse.Index, itemGetterKind); chain.IsArrayItem = false; return(result); } else { // we are at the beginning of the field chain // // 4: a[x]->... // Lengthen chain for itself chain.Lengthen(); // for own [] chain.IsArrayItem = true; chain.IsLastMember = true; result = chain.EmitGetItem(itemuse.Array, itemuse.Index, itemGetterKind); chain.IsArrayItem = false; return(result); } } // 1, 2, 6, 7 if (node.IsMemberOf != null) { // last node of the field chain // // 6 , 7: ...->a[]_[]_ , ...->a_[]_ bool quiet_read = chain.QuietRead; chain.Create(); chain.Begin(); chain.QuietRead = quiet_read; chain.Lengthen(); // for hop over -> node.IsMemberOf.Emit(codeGenerator); // let's emit the itemuse.Array subchain followed by the GetItem: chain.IsArrayItem = true; chain.IsLastMember = false; result = chain.EmitGetItem(itemuse.Array, itemuse.Index, itemGetterKind); chain.IsArrayItem = false; chain.End(); return(result); } // 1, 2 if (itemuse.Array is ItemUse || itemuse.Array is DirectStFldUse || itemuse.Array is IndirectStFldUse) { // we are at the beginning of the field chain // // 2: a[]_[]_ bool quiet_read = chain.QuietRead; chain.Create(); chain.Begin(); chain.QuietRead = quiet_read; chain.IsArrayItem = true; chain.IsLastMember = true; result = chain.EmitGetItem(itemuse.Array, itemuse.Index, itemGetterKind); chain.IsArrayItem = false; chain.End(); return(result); } // no chains // // 1: a_[x]_ chain.IsArrayItem = true; chain.IsLastMember = true; result = chain.EmitGetItem(itemuse.Array, itemuse.Index, itemGetterKind); chain.IsArrayItem = false; return(result); }
void IPhpPropertySymbol.EmitInit(CodeGenerator cg) { throw new NotSupportedException(); }
public override PhpTypeCode Emit(LambdaFunctionExpr node, CodeGenerator codeGenerator) { Statistics.AST.AddNode("LambdaFunctionExpr"); var typeBuilder = codeGenerator.IL.TypeBuilder; // define argless and argfull this.function.DefineBuilders(typeBuilder); // codeGenerator.MarkSequencePoint(node.Span); if (!codeGenerator.EnterFunctionDeclaration(function)) { throw new Exception("EnterFunctionDeclaration() failed!"); } codeGenerator.EmitArgfullOverloadBody(function, node.Body, node.EntireDeclarationSpan, node.DeclarationBodyPosition); codeGenerator.LeaveFunctionDeclaration(); // new Closure( <context>, new RoutineDelegate(null,function.ArgLess), <parameters>, <static> ) codeGenerator.EmitLoadScriptContext(); var /*!*/ il = codeGenerator.IL; il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Ldftn, function.ArgLessInfo); il.Emit(OpCodes.Newobj, Constructors.RoutineDelegate); if (node.Signature.FormalParams != null && node.Signature.FormalParams.Length != 0) { // array = new PhpArray(<int_count>, <string_count>); il.Emit(OpCodes.Ldc_I4, 0); il.Emit(OpCodes.Ldc_I4, node.Signature.FormalParams.Length); il.Emit(OpCodes.Newobj, Constructors.PhpArray.Int32_Int32); foreach (var p in node.Signature.FormalParams) { // CALL array.SetArrayItem("&$name", "<required>" | "<optional>"); il.Emit(OpCodes.Dup); // PhpArray string keyValue = string.Format("{0}${1}", p.PassedByRef ? "&" : null, p.Name.Value); il.Emit(OpCodes.Ldstr, keyValue); il.Emit(OpCodes.Ldstr, (p.InitValue != null) ? "<optional>" : "<required>"); il.LdcI4(IntStringKey.StringKeyToArrayIndex(keyValue)); il.Emit(OpCodes.Call, Methods.PhpArray.SetArrayItemExact_String); } } else { il.Emit(OpCodes.Ldnull); } if (node.UseParams != null && node.UseParams.Count != 0) { // array = new PhpArray(<int_count>, <string_count>); il.Emit(OpCodes.Ldc_I4, 0); il.Emit(OpCodes.Ldc_I4, node.UseParams.Count); il.Emit(OpCodes.Newobj, Constructors.PhpArray.Int32_Int32); foreach (var p in node.UseParams) { // <stack>.SetArrayItem{Ref} il.Emit(OpCodes.Dup); // PhpArray string variableName = p.Name.Value; il.Emit(OpCodes.Ldstr, variableName); if (p.PassedByRef) { DirectVarUseCompiler.EmitLoadRef(codeGenerator, p.Name); il.Emit(OpCodes.Call, Methods.PhpArray.SetArrayItemRef_String); } else { // LOAD PhpVariable.Copy( <name>, Assigned ) DirectVarUseCompiler.EmitLoad(codeGenerator, p.Name); il.LdcI4((int)CopyReason.Assigned); il.Emit(OpCodes.Call, Methods.PhpVariable.Copy); // .SetArrayItemExact( <stack>, <stack>, <hashcode> ) il.LdcI4(IntStringKey.StringKeyToArrayIndex(variableName)); il.Emit(OpCodes.Call, Methods.PhpArray.SetArrayItemExact_String); } } } else { il.Emit(OpCodes.Ldnull); } il.Emit(OpCodes.Newobj, typeof(PHP.Library.SPL.Closure).GetConstructor(new Type[] { typeof(ScriptContext), typeof(RoutineDelegate), typeof(PhpArray), typeof(PhpArray) })); return(PhpTypeCode.Object); }
public ExpTranslator(CodeGenerator gen, SymbolGenerator gensym) { this.m = gen; this.gensym = gensym; }
public static bool IsValidJavascriptId(string id) { return(string.IsNullOrEmpty(id) || CodeGenerator.IsValidLanguageIndependentIdentifier(id)); }
public async Task <Models.File> SavePublicFileAsync(IFormFile file) { try { var fileInfo = new Models.File() { Id = 0, Name = file.FileName, Path = Config.publicFilePath + DateTime.Now.ToString("yyyyMMddHHmmss") + CodeGenerator.GetCode(10), Size = file.Length }; using (var stream = System.IO.File.Create(fileInfo.Path)) { await file.CopyToAsync(stream); } await dbContext.Files.AddAsync(fileInfo); await dbContext.SaveChangesAsync(); return(fileInfo); } catch (Exception e) { logger.LogError(e.Message); throw new Exception("Server Failed to Save File"); } }
/// <summary> /// Generates classes for the schemaFileName specified. /// </summary> public override void Execute() { // Load the XmlSchema and its collection. XmlSchema xsd; string xsdImportPath; using (FileStream fs = new FileStream(this.xsdFile, FileMode.Open)) { xsd = XmlSchema.Read(fs, null); XmlSchemaSet schemaSet = new XmlSchemaSet(); schemaSet.Add(xsd); foreach (XmlSchemaImport import in xsd.Includes) { xsdImportPath = ResolveImportPath(import); using (FileStream fsSchemaImport = new FileStream(xsdImportPath, FileMode.Open)) { XmlSchema xsdTemp = XmlSchema.Read(fsSchemaImport, null); schemaSet.Add(xsdTemp); } } schemaSet.Compile(); } XmlSchemas schemas = new XmlSchemas(); schemas.Add(xsd); foreach (XmlSchemaImport import in xsd.Includes) { xsdImportPath = ResolveImportPath(import); using (FileStream fs = new FileStream(xsdImportPath, FileMode.Open)) { XmlSchema xsdTemp = XmlSchema.Read(fs, null); schemas.Add(xsdTemp); } } // Create the importer for these schemas. XmlSchemaImporter importer = new XmlSchemaImporter(schemas); // System.CodeDom namespace for the XmlCodeExporter to put classes in. CodeNamespace ns = new CodeNamespace(this.targetNamespace); XmlCodeExporter exporter = new XmlCodeExporter(ns); List <XmlTypeMapping> mappings = new List <XmlTypeMapping>(); foreach (XmlSchemaType type in xsd.SchemaTypes.Values) { mappings.Add(importer.ImportSchemaType(type.QualifiedName)); } if (!this.ProcessComplexTypesOnly) { foreach (XmlSchemaElement element in xsd.Elements.Values) { mappings.Add(importer.ImportTypeMapping(element.QualifiedName)); } } foreach (XmlTypeMapping mapping in mappings) { exporter.ExportTypeMapping(mapping); } CodeGenerator.ValidateIdentifiers(ns); compileUnit = new CodeCompileUnit(); schemas.Remove(xsd); //Remove Types from CodeCompileUnit that belong to the imported schemas RemoveTypes(schemas, ns); compileUnit.Namespaces.Add(ns); }
#pragma warning restore VSTHRD010 private void Execute(bool withRegeneration) { var generationItems = new List <GenerationItem>(); var projectDictionary = new Dictionary <Project, Tuple <HashSet <TargetAsset>, HashSet <IReferencedAssembly> > >(); var messageLogger = new AggregateLogger(); messageLogger.Initialize(); Attempt.Action( () => { ThreadHelper.ThrowIfNotOnUIThread(); #pragma warning disable VSTHRD010 if (!IsAvailable) { throw new InvalidOperationException("Cannot generate unit tests for this item because no supported files were found"); } var options = _package.Options; var sources = SolutionUtilities.GetSelectedFiles(_dte, true, options.GenerationOptions).Where(ProjectItemModel.IsSupported).ToList(); var targetProjects = new Dictionary <Project, Project>(); foreach (var source in sources) { if (targetProjects.ContainsKey(source.Project)) { continue; } if (source.TargetProject == null && options.GenerationOptions.CreateProjectAutomatically) { var testProject = SolutionUtilities.CreateTestProjectInCurrentSolution(_dte, source.Project, options.GenerationOptions); ReferencesHelper.AddNugetPackagesToProject(testProject, StandardReferenceHelper.GetReferencedNugetPackages(options), messageLogger.LogMessage, _package); } var targetProject = source.TargetProject; if (targetProject == null && !options.GenerationOptions.AllowGenerationWithoutTargetProject) { throw new InvalidOperationException("Cannot create tests for '" + Path.GetFileName(source.FilePath) + "' because there is no project '" + source.TargetProjectName + "'"); } if (targetProject != null) { targetProjects[source.Project] = targetProject; projectDictionary[targetProject] = Tuple.Create(new HashSet <TargetAsset>(), new HashSet <IReferencedAssembly>()); } } foreach (var source in sources) { var projectItem = source.Item; if (!withRegeneration && TargetFinder.FindExistingTargetItem(source, options.GenerationOptions, out _) == FindTargetStatus.Found) { if (sources.Count == 1) { throw new InvalidOperationException("Cannot create tests for '" + Path.GetFileName(source.FilePath) + "' because tests already exist. If you want to re-generate tests for this item, hold down the left Shift key and right-click the item."); } continue; } var nameParts = VsProjectHelper.GetNameParts(projectItem); targetProjects.TryGetValue(source.Project, out var targetProject); var targetProjectItems = TargetFinder.FindTargetFolder(targetProject, nameParts, true, out var targetPath); if (targetProjectItems == null && !options.GenerationOptions.AllowGenerationWithoutTargetProject) { // we asked to create targetProjectItems - so if it's null we effectively had a problem getting to the target project throw new InvalidOperationException("Cannot create tests for '" + Path.GetFileName(source.FilePath) + "' because there is no project '" + source.TargetProjectName + "'"); } var sourceNameSpaceRoot = VsProjectHelper.GetProjectRootNamespace(source.Project); HashSet <TargetAsset> requiredAssets; HashSet <IReferencedAssembly> referencedAssemblies; if (targetProject != null && projectDictionary.TryGetValue(targetProject, out var targetProjectEntry)) { requiredAssets = targetProjectEntry.Item1; referencedAssemblies = targetProjectEntry.Item2; } else { requiredAssets = new HashSet <TargetAsset>(); referencedAssemblies = new HashSet <IReferencedAssembly>(); } Func <string, string> namespaceTransform; if (source.TargetProject != null) { var targetNameSpaceRoot = VsProjectHelper.GetProjectRootNamespace(source.TargetProject); namespaceTransform = NamespaceTransform.Create(sourceNameSpaceRoot, targetNameSpaceRoot); } else { namespaceTransform = x => x + ".Tests"; } generationItems.Add(new GenerationItem(source, null, targetProjectItems, targetPath, requiredAssets, referencedAssemblies, namespaceTransform, options.GenerationOptions)); } #pragma warning restore VSTHRD010 }, _package); if (generationItems.Any()) { _package.JoinableTaskFactory.RunAsync(() => Attempt.ActionAsync(() => CodeGenerator.GenerateCodeAsync(generationItems, withRegeneration, _package, projectDictionary, messageLogger), _package)); } }
protected ScriptCodeGenerator(CodeGenerator parent) : base(parent) { }
internal override PhpTypeCode EmitAssign(ItemUse node, CodeGenerator codeGenerator) { var chain = codeGenerator.ChainBuilder; PhpTypeCode result; switch (access) { case AccessType.WriteAndReadRef: case AccessType.WriteAndReadUnknown: case AccessType.ReadAndWrite: case AccessType.ReadAndWriteAndReadRef: case AccessType.ReadAndWriteAndReadUnknown: case AccessType.Write: case AccessType.WriteRef: { bool reference = access == AccessType.WriteRef; // Note that some work was done in Emit() ! // In cases 3, 4, 5 EmitAssign is not called if (node.IsMemberOf != null || (node.IsMemberOf == null && (node.Array is DirectStFldUse || node.Array is IndirectStFldUse || node.Array is ItemUse))) { // 2, 6, 7 chain.EmitSetArrayItem(indexTypeCode, node.Index, reference); chain.End(); } else { // Note: The value which should be stored is already loaded on the evaluation stack. // Push the destination array and index and call the operator // 1: a_[x]_ Debug.Assert(node.Array is SimpleVarUse); chain.IsArrayItem = true; chain.IsLastMember = true; indexTypeCode = codeGenerator.EmitArrayKey(chain, node.Index); node.Array.Emit(codeGenerator); chain.EmitSetItem(indexTypeCode, node.Index, reference); // Store the changed variable into table of variables (do nothing in optimalized functions) SimpleVarUseHelper.EmitLoadAddress_StoreBack((SimpleVarUse)node.Array, codeGenerator); } result = PhpTypeCode.Void; break; } case AccessType.None: // do nothing result = PhpTypeCode.Void; break; case AccessType.Read: // do nothing result = PhpTypeCode.Object; break; case AccessType.ReadRef: // Do nothing result = PhpTypeCode.PhpReference; break; default: Debug.Fail(null); result = PhpTypeCode.Invalid; break; } return(result); }
void IGenerator.Generate(CodeGenerator cg) => Emit(cg);
void EmitPhpCtors(ImmutableArray <MethodSymbol> instancectors, Emit.PEModuleBuilder module, DiagnosticBag diagnostics) { foreach (SynthesizedPhpCtorSymbol ctor in instancectors) { module.SetMethodBody(ctor, MethodGenerator.GenerateMethodBody(module, ctor, il => { Debug.Assert(SpecialParameterSymbol.IsContextParameter(ctor.Parameters[0])); var cg = new CodeGenerator(il, module, diagnostics, module.Compilation.Options.OptimizationLevel, false, this, new ParamPlace(ctor.Parameters[0]), new ArgPlace(this, 0)) { CallerType = this, ContainingFile = ContainingFile, }; Debug.Assert(ctor.BaseCtor != null); // base..ctor or this..ctor cg.EmitPop(cg.EmitForwardCall(ctor.BaseCtor, ctor)); if (ctor.PhpConstructor == null) { // initialize <ctx> field, if field is declared within this type var ctxField = this.ContextStore; if (ctxField != null && object.ReferenceEquals((object)ctxField.ContainingType, this)) { var ctxFieldPlace = new FieldPlace(cg.ThisPlaceOpt, ctxField, module); // Debug.Assert(<ctx> != null) cg.EmitDebugAssertNotNull(cg.ContextPlaceOpt, "Context cannot be null."); // <this>.<ctx> = <ctx> ctxFieldPlace.EmitStorePrepare(il); cg.EmitLoadContext(); ctxFieldPlace.EmitStore(il); } // trait specific: if (ctor is SynthesizedPhpTraitCtorSymbol tctor) { EmitTraitCtorInit(cg, tctor); } // trait instances: foreach (var t in this.TraitUses) { EmitTraitInstanceInit(cg, ctor, t); } // initialize instance fields: foreach (var f in this.GetMembers().OfType <IPhpPropertySymbol>().Where(f => f.FieldKind == PhpPropertyKind.InstanceField)) { Debug.Assert(f.ContainingStaticsHolder == null); f.EmitInit(cg); } } else { Debug.Assert(ctor.BaseCtor.ContainingType == this); // this.__construct cg.EmitPop(cg.EmitForwardCall(ctor.PhpConstructor, ctor)); } // ret Debug.Assert(ctor.ReturnsVoid); cg.EmitRet(ctor.ReturnType); }, null, diagnostics, false)); } }
protected override string GenerateCode(LanguageProperties language, IClass currentClass) { StringBuilder code = new StringBuilder(); var line = editor.Document.GetLineForOffset(startAnchor.Offset); string indent = DocumentUtilitites.GetWhitespaceAfter(editor.Document, line.Offset); CodeGenerator generator = language.CodeGenerator; if (Options.AddIEquatableInterface) { // TODO : add IEquatable<T> to class // IAmbience ambience = currentClass.CompilationUnit.Language.GetAmbience(); // // IReturnType baseRType = currentClass.CompilationUnit.ProjectContent.GetClass("System.IEquatable", 1).DefaultReturnType; // // IClass newClass = new DefaultClass(currentClass.CompilationUnit, currentClass.FullyQualifiedName, currentClass.Modifiers, currentClass.Region, null); // // foreach (IReturnType type in currentClass.BaseTypes) { // newClass.BaseTypes.Add(type); // } // // // newClass.BaseTypes.Add(new ConstructedReturnType(baseRType, new List<IReturnType>() { currentClass.DefaultReturnType })); // // ambience.ConversionFlags = ConversionFlags.IncludeBody; // // string a = ambience.Convert(currentClass); // // int startOffset = editor.Document.PositionToOffset(currentClass.Region.BeginLine, currentClass.Region.BeginColumn); // int endOffset = editor.Document.PositionToOffset(currentClass.BodyRegion.EndLine, currentClass.BodyRegion.EndColumn); // // editor.Document.Replace(startOffset, endOffset - startOffset, a); } if (Options.SurroundWithRegion) { editor.Document.InsertNormalized(startAnchor.Offset, "#region Equals and GetHashCode implementation\n" + indent); } string codeForMethodBody; if ("Equals".Equals(selectedMethod.Name, StringComparison.Ordinal)) { IList <MethodDeclaration> equalsOverrides = CreateEqualsOverrides(currentClass); MethodDeclaration defaultOverride = equalsOverrides.First(); equalsOverrides = equalsOverrides.Skip(1).ToList(); StringBuilder builder = new StringBuilder(); foreach (AbstractNode element in defaultOverride.Body.Children.OfType <AbstractNode>()) { builder.Append(language.CodeGenerator.GenerateCode(element, indent + "\t")); } codeForMethodBody = builder.ToString().Trim(); if (addOtherMethod.IsChecked == true) { if (equalsOverrides.Any()) { code.Append(indent + "\n" + string.Join("\n", equalsOverrides.Select(item => generator.GenerateCode(item, indent)))); } code.Append(indent + "\n" + generator.GenerateCode(CreateGetHashCodeOverride(currentClass), indent)); } } else { StringBuilder builder = new StringBuilder(); foreach (AbstractNode element in CreateGetHashCodeOverride(currentClass).Body.Children.OfType <AbstractNode>()) { builder.Append(language.CodeGenerator.GenerateCode(element, indent + "\t")); } codeForMethodBody = builder.ToString().Trim(); if (addOtherMethod.IsChecked == true) { code.Append(indent + "\n" + string.Join("\n", CreateEqualsOverrides(currentClass).Select(item => generator.GenerateCode(item, indent)))); } } if (Options.AddOperatorOverloads) { var checkStatements = new[] { new IfElseStatement( new InvocationExpression( new IdentifierExpression("ReferenceEquals"), new List <Expression>() { new IdentifierExpression("lhs"), new IdentifierExpression("rhs") } ), new ReturnStatement(new PrimitiveExpression(true)) ), new IfElseStatement( new BinaryOperatorExpression( new InvocationExpression( new IdentifierExpression("ReferenceEquals"), new List <Expression>() { new IdentifierExpression("lhs"), new PrimitiveExpression(null) } ), BinaryOperatorType.LogicalOr, new InvocationExpression( new IdentifierExpression("ReferenceEquals"), new List <Expression>() { new IdentifierExpression("rhs"), new PrimitiveExpression(null) } ) ), new ReturnStatement(new PrimitiveExpression(false)) ) }; BlockStatement equalsOpBody = new BlockStatement() { Children = { new ReturnStatement( new InvocationExpression( new MemberReferenceExpression(new IdentifierExpression("lhs"), "Equals"), new List <Expression>() { new IdentifierExpression("rhs") } ) ) } }; if (currentClass.ClassType == Dom.ClassType.Class) { equalsOpBody.Children.InsertRange(0, checkStatements); } BlockStatement notEqualsOpBody = new BlockStatement() { Children = { new ReturnStatement( new UnaryOperatorExpression( new ParenthesizedExpression( new BinaryOperatorExpression( new IdentifierExpression("lhs"), BinaryOperatorType.Equality, new IdentifierExpression("rhs") ) ), UnaryOperatorType.Not ) ) } }; code.Append(indent + "\n" + generator.GenerateCode(CreateOperatorOverload(OverloadableOperatorType.Equality, currentClass, equalsOpBody), indent)); code.Append(indent + "\n" + generator.GenerateCode(CreateOperatorOverload(OverloadableOperatorType.InEquality, currentClass, notEqualsOpBody), indent)); } if (Options.SurroundWithRegion) { code.AppendLine(indent + "#endregion"); } editor.Document.InsertNormalized(insertionEndAnchor.Offset, code.ToString()); return(codeForMethodBody); }