static void AddErrorHelpers(CodeTypeDeclaration type)
{
var minusOne = Expression.Primitive(-1);
var errors = type.AddProperty <CompilerErrorCollection> ("Errors").AsProtected()
.WithGetLazyInitialize(
type.AddField <CompilerErrorCollection> ("errors"),
init: Expression.New <CompilerErrorCollection> ())
.OnThis();
type.AddMethod("Error")
.WithParameter <string> ("message", out var paramErrorMessage)
.WithStatements(
errors.InvokeMethod(
"Add",
Expression.New <CompilerError> (Expression.Null, minusOne, minusOne, Expression.Null, paramErrorMessage)
));
type.AddMethod("Warning")
.WithParameter("message", TypeReference.String, out var paramWarningMessage)
.WithStatements(
Statement.DeclareVariable <CompilerError> ("val",
Expression.New <CompilerError> (Expression.Null, minusOne, minusOne, Expression.Null, paramWarningMessage),
out var val),
val.SetProperty("IsWarning", Expression.True),
errors.InvokeMethod("Add", val).AsStatement()
);
}
private static void AddProperties(this CodeTypeDeclaration targetClass, CodeNamespace codeNamespace, IRecordDescriptor descriptor, out bool hasArrayType)
{
hasArrayType = false;
foreach (var field in descriptor.Fields)
{
if (field.Value.IsArray)
{
codeNamespace.GenerateClass((IRecordDescriptor)field.Value, $"{field.Key}Item", out hasArrayType);
targetClass.AddArrayProperty(field.Key, $"{field.Key}Item");
hasArrayType = true;
continue;
}
targetClass.AddProperty(field.Key, field.Value);
}
}
static void GenerateProcessingHelpers(CodeTypeDeclaration type)
{
var builderFieldDef = type.AddField <StringBuilder> ("builder").WithReference(out var builder);
var sessionFieldDef = type.AddField <IDictionary <string, object> > ("session");
type.AddPropertyGetSet("Session", sessionFieldDef).AsVirtual();
type.AddProperty <StringBuilder> ("GenerationEnvironment")
.WithSet(builder)
.WithGetLazyInitialize(builder, builderFieldDef.Type.New());
AddErrorHelpers(type);
AddIndentHelpers(type);
AddWriteHelpers(type);
}
CodeTypeDeclaration CreateMySettingsProperty(SettingsDocument setDoc)
{
CodeTypeDeclaration c = new CodeTypeDeclaration("MySettingsProperty");
c.UserData["Module"] = true;
c.AddAttribute(new CodeTypeReference("Microsoft.VisualBasic.HideModuleNameAttribute"));
c.AddAttribute(typeof(DebuggerNonUserCodeAttribute));
c.AddAttribute(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute));
c.TypeAttributes = TypeAttributes.NotPublic;
CodeTypeReference r = new CodeTypeReference(setDoc.GeneratedFullClassName);
var p = c.AddProperty(r, "Settings");
p.Attributes = MemberAttributes.Assembly | MemberAttributes.Static;
p.Getter.Return(Easy.Type(r).Property("Default"));
p.AddAttribute(typeof(System.ComponentModel.Design.HelpKeywordAttribute), Easy.Prim("My.Settings"));
return(c);
}
private void Create_SOContainer(CodeNamespace pNameSpace, CodeNamespaceImport[] arrDefaultUsing, CodeTypeDeclaration pType, CodeTypeDeclaration[] arrEnumType, out CodeTypeDeclaration pContainerType, out CodeMemberMethod pInitMethod)
{
string strContainerTypeName = pType.Name + "_Container";
pContainerType = new CodeTypeDeclaration(strContainerTypeName);
pContainerType.AddBaseClass("UnityEngine.ScriptableObject");
pNameSpace.Imports.Clear();
pNameSpace.Imports.AddRange(arrDefaultUsing);
pNameSpace.Imports.Add(new CodeNamespaceImport("System.Linq"));
pNameSpace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
pNameSpace.Types.Clear();
pNameSpace.Types.Add(pContainerType);
pNameSpace.Types.AddRange(arrEnumType);
pContainerType.AddField(new FieldTypeData(const_strFieldName_private_instance, strContainerTypeName), MemberAttributes.Private | MemberAttributes.Static);
var pPublicInstanceProperty = pContainerType.AddProperty(new FieldTypeData(const_strFieldName_instance, strContainerTypeName), MemberAttributes.Public | MemberAttributes.Static);
pPublicInstanceProperty.GetStatements.Add(new CodeSnippetStatement($" return {const_strFieldName_private_instance};"));
pContainerType.AddField(new FieldTypeData(const_strFieldName_ListData, $"List<{pType.Name}>"));
pInitMethod = Generate_InitMethod(pContainerType, pType.Name);
}
static void ProcessType(Type type, CodeTypeDeclaration ctd)
{
foreach (FieldInfo field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic))
{
ctd.AddField(ConvertType(field.FieldType), field.Name).Attributes = 0;
}
foreach (FieldInfo field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic))
{
EasyProperty p = ctd.AddProperty(ConvertType(field.FieldType), GetPropertyName(field.Name));
p.Getter.Return(Easy.Var(field.Name));
CodeExpression ex;
if (field.FieldType.IsValueType)
{
ex = new CodePropertySetValueReferenceExpression();
}
else
{
ex = GetDefaultValue("value", field);
}
p.Setter.Assign(Easy.Var(field.Name), ex);
if (typeof(INode).IsAssignableFrom(field.FieldType))
{
if (typeof(INullable).IsAssignableFrom(field.FieldType))
{
p.SetStatements.Add(new CodeSnippetStatement("\t\t\t\tif (!" + field.Name + ".IsNull) " + field.Name + ".Parent = this;"));
}
else
{
p.SetStatements.Add(new CodeSnippetStatement("\t\t\t\t" + field.Name + ".Parent = this;"));
}
}
}
foreach (ConstructorInfo ctor in type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
CodeConstructor c = new CodeConstructor();
if (type.IsAbstract)
{
c.Attributes = MemberAttributes.Family;
}
else
{
c.Attributes = MemberAttributes.Public;
}
ctd.Members.Add(c);
ConstructorInfo baseCtor = GetBaseCtor(type);
foreach (ParameterInfo param in ctor.GetParameters())
{
c.Parameters.Add(new CodeParameterDeclarationExpression(ConvertType(param.ParameterType),
param.Name));
if (baseCtor != null && Array.Exists(baseCtor.GetParameters(), delegate(ParameterInfo p) { return(param.Name == p.Name); }))
{
continue;
}
c.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(GetPropertyName(param.Name)),
new CodeVariableReferenceExpression(param.Name)));
}
if (baseCtor != null)
{
foreach (ParameterInfo param in baseCtor.GetParameters())
{
c.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(param.Name));
}
}
// initialize fields that were not initialized by parameter
foreach (FieldInfo field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic))
{
if (field.FieldType.IsValueType && field.FieldType != typeof(Location))
{
continue;
}
if (Array.Exists(ctor.GetParameters(), delegate(ParameterInfo p) { return(field.Name == p.Name); }))
{
continue;
}
c.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(field.Name),
GetDefaultValue(null, field)));
}
}
}
public static CodeMemberProperty AddPropertyGetOnly(this CodeTypeDeclaration type, string propertyName, CodeMemberField backingField) => type.AddProperty(propertyName, backingField.Type) .WithGet(Expression.This.Field(backingField));
public static CodeMemberProperty AddProperty <T> (this CodeTypeDeclaration type, string propertyName) => type.AddProperty(propertyName, TypeReference <T> .Global);
public virtual CodeTypeDeclaration CreateClass(SettingsDocument setDoc)
{
CodeTypeDeclaration c = new CodeTypeDeclaration(setDoc.GeneratedClassName);
c.AddAttribute(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute));
c.AddAttribute(typeof(System.CodeDom.Compiler.GeneratedCodeAttribute),
Easy.Prim(typeof(SettingsCodeGeneratorTool).FullName),
Easy.Prim(typeof(SettingsCodeGeneratorTool).Assembly.GetName().Version.ToString()));
c.TypeAttributes = TypeAttributes.NotPublic | TypeAttributes.Sealed;
c.IsPartial = true;
c.BaseTypes.Add(Easy.TypeRef(typeof(ApplicationSettingsBase)));
CodeMemberField f = c.AddField(Easy.TypeRef(c), "defaultInstance");
f.Attributes = MemberAttributes.Private | MemberAttributes.Static;
f.InitExpression = Easy.Type(typeof(ApplicationSettingsBase))
.InvokeMethod("Synchronized", Easy.New(Easy.TypeRef(c)))
.CastTo(Easy.TypeRef(c));
var defaultProperty = c.AddProperty(f, "Default");
if (setDoc.UseMySettingsClassName)
{
c.AddAttribute(typeof(EditorBrowsableAttribute), Easy.Prim(EditorBrowsableState.Advanced));
AddAutoSaveLogic(c, defaultProperty);
}
foreach (SettingsEntry entry in setDoc.Entries)
{
Type entryType = entry.Type ?? typeof(string);
SpecialSetting?specialSetting = null;
foreach (SpecialTypeDescriptor desc in SpecialTypeDescriptor.Descriptors)
{
if (desc.type == entryType)
{
entryType = typeof(string);
specialSetting = desc.specialSetting;
break;
}
}
EasyProperty p = c.AddProperty(entryType, entry.Name);
if (entry.Scope == SettingScope.User)
{
p.AddAttribute(typeof(UserScopedSettingAttribute));
}
else
{
p.AddAttribute(typeof(ApplicationScopedSettingAttribute));
}
if (!string.IsNullOrEmpty(entry.Provider))
{
p.AddAttribute(typeof(SettingsProviderAttribute),
Easy.TypeOf(new CodeTypeReference(entry.Provider)));
}
if (!string.IsNullOrEmpty(entry.Description))
{
p.AddAttribute(typeof(SettingsDescriptionAttribute), Easy.Prim(entry.Description));
Easy.AddSummary(p, entry.Description);
}
p.AddAttribute(typeof(DebuggerNonUserCodeAttribute));
if (specialSetting != null)
{
p.AddAttribute(typeof(SpecialSettingAttribute),
Easy.Prim(specialSetting.Value));
}
if (entry.GenerateDefaultValueInCode)
{
p.AddAttribute(typeof(DefaultSettingValueAttribute), Easy.Prim(entry.SerializedValue));
}
if (entry.Scope == SettingScope.User && entry.Roaming)
{
p.AddAttribute(typeof(SettingsManageabilityAttribute),
Easy.Prim(SettingsManageability.Roaming));
}
p.Getter.Return(Easy.This.Index(Easy.Prim(entry.Name)).CastTo(entryType));
// p.GetStatements.Add(new CodeMethodReturnStatement(
// new CodeCastExpression(new CodeTypeReference(entryType),
// new CodeIndexerExpression(new CodeThisReferenceExpression(),
// new CodePrimitiveExpression(entry.Name))
// )
// ));
if (entry.Scope == SettingScope.User)
{
p.Setter.Assign(Easy.This.Index(Easy.Prim(entry.Name)), Easy.Value);
}
}
return(c);
}
private void GenerateClient(string name, CodeNamespace ns, int complex_type_count)
{
CodeTypeDeclaration type = ns.AddType(name);
type.IsClass = true;
type.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
type.BaseTypes.Add(typeof(RpcAlpcClientBase));
CodeConstructor constructor = type.AddConstructor(MemberAttributes.Public | MemberAttributes.Final);
constructor.BaseConstructorArgs.Add(CodeGenUtils.GetPrimitive(_server.InterfaceId.ToString()));
constructor.BaseConstructorArgs.Add(CodeGenUtils.GetPrimitive(_server.InterfaceVersion.Major));
constructor.BaseConstructorArgs.Add(CodeGenUtils.GetPrimitive(_server.InterfaceVersion.Minor));
foreach (var proc in _server.Procedures)
{
string proc_name = proc.Name;
if (!_proc_names.Add(proc_name))
{
proc_name = $"{proc_name}_{proc.ProcNum}";
if (!_proc_names.Add(proc_name))
{
throw new ArgumentException($"Duplicate name {proc.Name}");
}
}
var method = type.AddMethod(proc_name, MemberAttributes.Public | MemberAttributes.Final);
RpcTypeDescriptor return_type = GetTypeDescriptor(proc.ReturnValue.Type);
if (return_type == null)
{
method.ThrowNotImplemented("Return type unsupported.");
continue;
}
var offset_to_name =
proc.Params.Select(p => Tuple.Create(p.Offset, p.Name)).ToList();
method.ReturnType = return_type.CodeType;
method.CreateMarshalObject(MARSHAL_NAME);
foreach (var p in proc.Params)
{
if (p == proc.Handle)
{
continue;
}
RpcTypeDescriptor p_type = GetTypeDescriptor(p.Type);
List <RpcMarshalArgument> extra_marshal_args = new List <RpcMarshalArgument>();
if (p_type.VarianceDescriptor.IsValid)
{
extra_marshal_args.Add(p_type.VarianceDescriptor.CalculateCorrelationArgument(p.Offset, offset_to_name));
}
var p_obj = method.AddParam(p_type.GetParameterType(), p.Name);
p_obj.Direction = p.GetDirection();
if (!p.IsIn)
{
continue;
}
if (p_type.Pointer)
{
if (p_type.PointerType == RpcPointerType.Reference)
{
method.AddNullCheck(MARSHAL_NAME, p.Name);
}
else
{
method.AddWriteReferent(MARSHAL_NAME, p.Name);
}
}
else if (!p_type.ValueType)
{
method.AddNullCheck(MARSHAL_NAME, p.Name);
}
method.AddMarshalCall(p_type, MARSHAL_NAME, p.Name, extra_marshal_args.ToArray());
// If it's a constructed type then ensure any deferred writes are flushed.
if (p_type.Constructed)
{
method.AddFlushDeferredWrites(MARSHAL_NAME);
}
}
method.SendReceive(MARSHAL_NAME, UNMARSHAL_NAME, proc.ProcNum);
foreach (var p in proc.Params.Where(x => x.IsOut))
{
if (p == proc.Handle)
{
continue;
}
RpcTypeDescriptor p_type = GetTypeDescriptor(p.Type);
if (p_type.Pointer)
{
method.AddPointerUnmarshalCall(p_type, UNMARSHAL_NAME, p.Name);
}
else
{
method.AddUnmarshalCall(p_type, UNMARSHAL_NAME, p.Name);
}
if (p_type.Constructed)
{
method.AddPopluateDeferredPointers(UNMARSHAL_NAME);
}
}
method.AddUnmarshalReturn(return_type, UNMARSHAL_NAME);
}
if (complex_type_count > 0 && HasFlag(RpcClientBuilderFlags.GenerateConstructorProperties))
{
var constructor_type = new CodeTypeReference(CodeGenUtils.MakeIdentifier(CONSTRUCTOR_STRUCT_NAME));
var prop = type.AddProperty("New", constructor_type, MemberAttributes.Public | MemberAttributes.Final,
new CodeMethodReturnStatement(new CodeObjectCreateExpression(constructor_type)));
constructor_type = new CodeTypeReference(CodeGenUtils.MakeIdentifier(ARRAY_CONSTRUCTOR_STRUCT_NAME));
type.AddProperty("NewArray", constructor_type, MemberAttributes.Public | MemberAttributes.Final,
new CodeMethodReturnStatement(new CodeObjectCreateExpression(constructor_type)));
}
}
