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 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 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);
}
