static void AddWriteHelpers(CodeTypeDeclaration type) { var generationEnvironment = Expression.This.Property("GenerationEnvironment"); var currentIndent = Expression.This.Field("currentIndent"); var textToAppendParamDef = Declare.Parameter <string> ("textToAppend").WithReference(out var textToAppend); var formatParamDef = Declare.Parameter <string> ("format").WithReference(out var format); var argsParamDef = Declare.Parameter <object[]> ("args").Params().WithReference(out var args); type.AddMethod("Write").WithParameter(textToAppendParamDef) .WithStatements( generationEnvironment.InvokeMethod("Append", textToAppend)); type.AddMethod("Write").WithParameters(formatParamDef, argsParamDef) .WithStatements( generationEnvironment.InvokeMethod("AppendFormat", format, args)); type.AddMethod("WriteLine").WithParameter(textToAppendParamDef) .WithStatements( generationEnvironment.InvokeMethod("Append", currentIndent).AsStatement(), generationEnvironment.InvokeMethod("AppendLine", textToAppend).AsStatement() ); type.AddMethod("WriteLine").WithParameters(formatParamDef, argsParamDef) .WithStatements( generationEnvironment.InvokeMethod("Append", currentIndent).AsStatement(), generationEnvironment.InvokeMethod("AppendFormat", format, args).AsStatement(), generationEnvironment.InvokeMethod("AppendLine").AsStatement() ); }
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 CodeMemberMethod Generate_InitMethod(CodeTypeDeclaration pContainerType, string strTypeName) { var pMethod = pContainerType.AddMethod($"DoInit", MemberAttributes.Public | MemberAttributes.Static); pMethod.Parameters.Add(new CodeParameterDeclarationExpression(pContainerType.Name, "pSingletonInstance")); pMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(bool), "bIsUpdateChildAsset")); pMethod.Statements.Add(new CodeSnippetStatement($" {const_strFieldName_private_instance} = pSingletonInstance;")); pMethod.Statements.Add(new CodeSnippetStatement("#if UNITY_EDITOR")); pMethod.Statements.Add(new CodeSnippetStatement(" if(bIsUpdateChildAsset)")); pMethod.Statements.Add(new CodeSnippetStatement(" {")); pMethod.Statements.Add(new CodeSnippetStatement($" {const_strFieldName_private_instance}.listData.Clear();")); pMethod.Statements.Add(new CodeSnippetStatement($" Object[] arrObject = UnityEditor.AssetDatabase.LoadAllAssetRepresentationsAtPath(UnityEditor.AssetDatabase.GetAssetPath({const_strFieldName_private_instance}));")); pMethod.Statements.Add(new CodeSnippetStatement(" for (int i = 0; i < arrObject.Length; i++)")); pMethod.Statements.Add(new CodeSnippetStatement($" {const_strFieldName_private_instance}.listData.Add(({strTypeName})arrObject[i]);")); pMethod.Statements.Add(new CodeSnippetStatement(" if(Application.isPlaying == false)")); pMethod.Statements.Add(new CodeSnippetStatement(" {")); pMethod.Statements.Add(new CodeSnippetStatement($" UnityEditor.EditorUtility.SetDirty({const_strFieldName_private_instance});")); pMethod.Statements.Add(new CodeSnippetStatement(" UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene());")); pMethod.Statements.Add(new CodeSnippetStatement(" }")); pMethod.Statements.Add(new CodeSnippetStatement(" }")); pMethod.Statements.Add(new CodeSnippetStatement("#endif")); return(pMethod); }
private static CodeMemberMethod AddMethod(CodeTypeDeclaration marshal_type, string method_name, CodeTypeReference generic_type, CodeTypeReference return_type, string name, CodeTypeReference[] pre_args, AdditionalArguments additional_args) { var method = marshal_type.AddMethod(method_name, MemberAttributes.Public | MemberAttributes.Final); method.ReturnType = return_type; int arg_count = 0; List <CodeExpression> arg_names = new List <CodeExpression>(pre_args.Select(a => AddParam(a, arg_count++, method))); arg_names.AddRange(additional_args.FixedArgs); arg_names.AddRange(additional_args.Params.Select(a => AddParam(a, arg_count++, method))); CodeMethodReferenceExpression generic_method = generic_type != null ? new CodeMethodReferenceExpression(null, name, generic_type) : new CodeMethodReferenceExpression(null, name); var invoke_method = new CodeMethodInvokeExpression(generic_method, arg_names.ToArray()); if (return_type != null) { method.AddReturn(invoke_method); } else { method.Statements.Add(invoke_method); } return(method); }
static CodeTypeDeclaration CreateNotImplementedAstVisitorClass(List <Type> nodeTypes) { CodeTypeDeclaration td = new CodeTypeDeclaration("NotImplementedAstVisitor"); td.TypeAttributes = TypeAttributes.Public | TypeAttributes.Class; td.BaseTypes.Add(new CodeTypeReference("IAstVisitor")); string comment = "<summary>\n " + "IAstVisitor implementation that always throws NotImplementedExceptions.\n " + "</summary>"; td.Comments.Add(new CodeCommentStatement(comment, true)); foreach (Type type in nodeTypes) { if (!type.IsAbstract) { EasyMethod m = td.AddMethod(typeof(object), VisitPrefix + type.Name); m.Attributes = MemberAttributes.Public; m.AddParameter(ConvertType(type), GetFieldName(type.Name)); m.AddParameter(new CodeTypeReference(typeof(object)), "data"); m.Body.Throw(Easy.New(typeof(NotImplementedException), Easy.Prim(type.Name))); } } return(td); }
public static CodeMemberMethod AddUnmarshalMethod(this CodeTypeDeclaration type, string unmarshal_name) { CodeMemberMethod method = type.AddMethod("Unmarshal", MemberAttributes.Final | MemberAttributes.Private); method.PrivateImplementationType = new CodeTypeReference(typeof(INdrStructure)); method.AddParam(typeof(NdrUnmarshalBuffer), unmarshal_name); return(method); }
public static void AddArrayConstructorMethod(this CodeTypeDeclaration type, string name, RpcTypeDescriptor complex_type) { CodeMemberMethod method = type.AddMethod(name, MemberAttributes.Public | MemberAttributes.Final); method.AddParam(new CodeTypeReference(typeof(int)), "size"); method.ReturnType = complex_type.GetArrayType(); method.AddReturn(new CodeArrayCreateExpression(complex_type.CodeType, GetVariable("size"))); }
public static CodeMemberMethod AddInequalityOperator(this CodeTypeDeclaration declaration) { var result = declaration.AddMethod("operator !=", typeof(bool)); result.AddParameter("value1", declaration.Name); result.AddParameter("value2", declaration.Name); result.Attributes = MemberAttributes.Public | MemberAttributes.Static; return(result); }
private void Generate_CacheMethod_Global(CodeTypeDeclaration pContainerType, CodeMemberMethod pInitMethod, string strListDataName, string strMapFieldName, string strTypeFieldName, string strTypeName, string strValueFieldName) { string strMethodName = $"Init_{strMapFieldName}"; var pMethod = pContainerType.AddMethod(strMethodName); pMethod.Attributes = MemberAttributes.Private | MemberAttributes.Final; CodeFieldReferenceExpression pCasheMemberReference = new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), strMapFieldName); CodeTypeReferenceExpression pField_List = new CodeTypeReferenceExpression($"{strListDataName}"); // 1. Where로 묶는다. CodeMethodInvokeExpression pMethod_CachingLocal = new CodeMethodInvokeExpression( pField_List, "Where", new CodeSnippetExpression($"x => x.{strTypeFieldName} == \"{strTypeName}\"")); CodeVariableDeclarationStatement pGroupbyVariableDeclaration = new CodeVariableDeclarationStatement( "var", "arrLocal", pMethod_CachingLocal); pMethod.Statements.Add(pGroupbyVariableDeclaration); // 3. Gropby로 묶은걸 Dictionary로 변환하며 할당한다. // 여기서 기본 형식은 다 형변환해야함 string strParseString = $"p.{strValueFieldName}"; if (strTypeName == "float") { strParseString = $"float.Parse({strParseString})"; } else if (strTypeName == "int") { strParseString = $"int.Parse({strParseString})"; } else if (strTypeFieldName == "string") { } else { strParseString = $"({strTypeName})System.Enum.Parse(typeof({strTypeName}), {strParseString})"; // SpreadSheetParser_MainForm.WriteConsole($"Error Parsing Not Define {strTypeName}"); } CodeMethodInvokeExpression pMethod_Caching = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression("arrLocal"), "ToDictionary", new CodeSnippetExpression($"p => p.{const_GlobalKey_FieldName}_{strTypeName}, p => {strParseString}")); CodeAssignStatement pCachAssign = new CodeAssignStatement(pCasheMemberReference, pMethod_Caching); pMethod.Statements.Add(pCachAssign); pInitMethod.Statements.Add(new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeSnippetExpression(const_strFieldName_private_instance), strMethodName))); }
public static CodeMemberMethod AddImplicitOperator(this CodeTypeDeclaration declaration, string toType) { var result = declaration.AddMethod("implicit operator " + toType, toType); result.AddParameter("value", declaration.Name); result.Attributes = MemberAttributes.Public | MemberAttributes.Static; result.ReturnType = new CodeTypeReference(); return(result); }
static void AddIndentHelpers(CodeTypeDeclaration type) { var zero = Expression.Primitive(0); type.AddPropertyGetOnly("CurrentIndent", type.AddField("currentIndent", TypeReference.String, init: Expression.StringEmpty) .WithReference(out var currentIndent)); type.AddProperty <Stack <int> > ("Indents").AsPrivate() .WithGetLazyInitialize( type.AddField <Stack <int> > ("indents"), Expression.New <Stack <int> > ()) .WithReference(out var indents); type.AddMethod("PopIndent").Returns <string> () .WithStatements( Statement.If(indents.Property("Count").IsEqualValue(zero), Then: Expression.StringEmpty.Return()), Statement.DeclareVariable <int> ("lastPos", currentIndent.Property("Length").Subtract(indents.InvokeMethod("Pop")), out var lastPosRef), Statement.DeclareVariable(TypeReference.String, "last", currentIndent.InvokeMethod("Substring", lastPosRef), out var lastRef), currentIndent.Assign(currentIndent.InvokeMethod("Substring", zero, lastPosRef)), lastRef.Return() ); type.AddMethod("PushIndent") .WithParameter("indent", TypeReference.String, out var paramIndent) .WithStatements( indents.InvokeMethod("Push", paramIndent.Property("Length")).AsStatement(), currentIndent.Assign(currentIndent.Add(paramIndent)) ); type.AddMethod("ClearIndent") .WithStatements( currentIndent.Assign(Expression.StringEmpty), indents.InvokeMethod("Clear").AsStatement() ); }
/// <summary> /// Adds an implementation of the INotifyPropertyChanged interface to the given type. /// </summary> /// <param name="type">The type declaration</param> /// <returns>Type with INotifyPropertyChanged implemented.</returns> protected CodeTypeDeclaration ImplementINotifyPropertyChanged(CodeTypeDeclaration type) { //// This method will implement the INotifyPropertyChanged interface //// Here's an example : //// public class Customer :INotifyPropertyChanged { //// public PropertyChangedEventHandler PropertyChanged; //// public void RaisePropertyChanged(string propertyName) { //// if( this.PropertyChanged !=null ) { //// this.PropertyChanged (this, new PropertyChangedEventArgs( propertyName ) ); //// } //// } //// } CodeThisReferenceExpression thisReference = new CodeThisReferenceExpression(); CodeTypeReference notifyPropertyChanged = Code.TypeRef(typeof(INotifyPropertyChanged)); // Add the implements INotifyPropertyChanged statement // public class Customer :INotifyPropertyChanged { type.BaseTypes.Add(notifyPropertyChanged); // Add the PropertyChanged event as a field to the type // public PropertyChangedEventHandler PropertyChanged; CodeMemberEvent propertyChangedEvent = type.AddEvent(Code.TypeRef(typeof(PropertyChangedEventHandler)), "PropertyChanged"); propertyChangedEvent.ImplementationTypes.Add(notifyPropertyChanged); // this.PropertyChanged CodeEventReferenceExpression eventFieldReference = new CodeEventReferenceExpression(thisReference, "PropertyChanged"); // Add the RaisePropertyChanged Method which will invoke the PropertyChanged handler whenever a property value changes // if( this.PropertyChanged !=null ) CodeConditionStatement invokeEventHandlersIfAny = new CodeConditionStatement(new CodeBinaryOperatorExpression(eventFieldReference, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null))); // this.PropertyChanged (this, new PropertyChangedEventArgs( propertyName ) ); invokeEventHandlersIfAny.TrueStatements.Add( new CodeDelegateInvokeExpression(eventFieldReference, new CodeExpression[] { thisReference, new CodeObjectCreateExpression("PropertyChangedEventArgs", new CodeArgumentReferenceExpression("propertyName")) })); // public void RaisePropertyChanged CodeMemberMethod method = type.AddMethod("RaisePropertyChanged", MemberAttributes.Public); method.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "propertyName")); //// public void RaisePropertyChanged(string propertyName) { //// if( this.PropertyChanged !=null ) { //// this.PropertyChanged (this, new PropertyChangedEventArgs( propertyName ) ); //// } //// } method.Statements.Add(invokeEventHandlersIfAny); return(type); }
public static void AddDefaultConstructorMethod(this CodeTypeDeclaration type, string name, MemberAttributes attributes, RpcTypeDescriptor complex_type, Dictionary <string, CodeExpression> initialize_expr) { CodeMemberMethod method = type.AddMethod(name, attributes); method.ReturnType = complex_type.CodeType; CodeExpression return_value = new CodeObjectCreateExpression(complex_type.CodeType); if (initialize_expr.Count > 0) { method.Statements.Add(new CodeVariableDeclarationStatement(complex_type.CodeType, "ret", return_value)); return_value = GetVariable("ret"); method.Statements.AddRange(initialize_expr.Select(p => new CodeAssignStatement(return_value.GetFieldReference(p.Key), p.Value)).ToArray()); } method.AddReturn(return_value); }
public static void AddConstructorMethod(this CodeTypeDeclaration type, string name, RpcTypeDescriptor complex_type, IEnumerable <Tuple <CodeTypeReference, string> > parameters) { if (!parameters.Any()) { return; } CodeMemberMethod method = type.AddMethod(name, MemberAttributes.Public | MemberAttributes.Final); method.ReturnType = complex_type.CodeType; method.Statements.Add(new CodeVariableDeclarationStatement(complex_type.CodeType, "ret", new CodeObjectCreateExpression(complex_type.CodeType))); CodeExpression return_value = GetVariable("ret"); method.AddAssignmentStatements(return_value, parameters); method.AddReturn(return_value); }
static CodeTypeDeclaration CreateAstVisitorInterface(List <Type> nodeTypes) { CodeTypeDeclaration td = new CodeTypeDeclaration("IAstVisitor"); td.IsInterface = true; foreach (Type t in nodeTypes) { if (!t.IsAbstract) { EasyMethod m = td.AddMethod(typeof(object), VisitPrefix + t.Name); m.AddParameter(ConvertType(t), GetFieldName(t.Name)); m.AddParameter(typeof(object), "data"); } } return(td); }
private void Generate_ExtensionMethod_ByEnumKey(CodeTypeDeclaration pEnumHelperClass, CodeTypeDeclaration pContainerType, string strMapFieldName, string strKeyTypeName, string strDataTypeName, bool bIsOverlapKey) { string strMethodName = $"Get{strDataTypeName}"; if (bIsOverlapKey) { strMethodName += "_List"; } var pMethod = pEnumHelperClass.AddMethod(strMethodName); pMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static; if (bIsOverlapKey) { pMethod.ReturnType = new CodeTypeReference($"List<{strDataTypeName}>"); } else { switch (strDataTypeName) { case "int": strDataTypeName = "System.Int32"; break; case "float": strDataTypeName = "System.Single"; break; } pMethod.ReturnType = new CodeTypeReference(strDataTypeName); } pMethod.Parameters.Add(new CodeParameterDeclarationExpression($"this {strKeyTypeName}", "eKey")); pMethod.Parameters.Add(new CodeParameterDeclarationExpression("System.Action<string>", "OnError = null")); pMethod.Statements.Add(new CodeSnippetStatement($" {pMethod.ReturnType.BaseType} pData;")); pMethod.Statements.Add(new CodeSnippetStatement($" if({pContainerType.Name}.{const_strFieldName_instance}.{strMapFieldName}.TryGetValue(eKey, out pData) == false)")); pMethod.Statements.Add(new CodeSnippetStatement(" {")); pMethod.Statements.Add(new CodeSnippetStatement($" if(OnError != null)")); pMethod.Statements.Add(new CodeSnippetStatement($" OnError(nameof({pContainerType.Name}) + \"- Not Found Data // Key : \" + eKey);")); pMethod.Statements.Add(new CodeSnippetStatement(" }")); if (bIsOverlapKey) { } pMethod.Statements.Add(new CodeSnippetStatement(" return pData;")); }
private void Generate_CacheMethod(CodeTypeDeclaration pContainerType, CodeMemberMethod pInitMethod, string strListDataName, string strMapFieldName, string strCacheFieldName, bool bIsOverlapKey) { string strMethodName = $"Init_{strMapFieldName}"; var pMethod = pContainerType.AddMethod(strMethodName); pMethod.Attributes = MemberAttributes.Private | MemberAttributes.Final; CodeFieldReferenceExpression pCasheMemberReference = new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), strMapFieldName); CodeTypeReferenceExpression pField_List = new CodeTypeReferenceExpression($"{strListDataName}"); if (bIsOverlapKey) { CodeMethodInvokeExpression pMethod_CachingLocal = new CodeMethodInvokeExpression( pField_List, "GroupBy", new CodeSnippetExpression($"x => x.{strCacheFieldName}")); CodeVariableDeclarationStatement pGroupbyVariableDeclaration = new CodeVariableDeclarationStatement( "var", "arrLocal", pMethod_CachingLocal); pMethod.Statements.Add(pGroupbyVariableDeclaration); CodeMethodInvokeExpression pMethod_Caching = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression("arrLocal"), "ToDictionary", new CodeSnippetExpression($"g => g.Key, g => g.ToList()")); CodeAssignStatement pCacheAssign = new CodeAssignStatement(pCasheMemberReference, pMethod_Caching); pMethod.Statements.Add(pCacheAssign); } else { CodeMethodInvokeExpression pMethod_Caching = new CodeMethodInvokeExpression( pField_List, "ToDictionary", new CodeSnippetExpression($"x => x.{strCacheFieldName}")); CodeAssignStatement pCacheAssign = new CodeAssignStatement(pCasheMemberReference, pMethod_Caching); pMethod.Statements.Add(pCacheAssign); } pInitMethod.Statements.Add(new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeSnippetExpression(const_strFieldName_private_instance), strMethodName))); }
static CodeTypeDeclaration CreateNodeTrackingAstVisitorClass(List <Type> nodeTypes) { CodeTypeDeclaration td = new CodeTypeDeclaration("NodeTrackingAstVisitor"); td.TypeAttributes = TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Abstract; td.BaseTypes.Add(new CodeTypeReference("AbstractAstVisitor")); string comment = "<summary>\n " + "The NodeTrackingAstVisitor will iterate through the whole AST,\n " + "just like the AbstractAstVisitor, and calls the virtual methods\n " + "BeginVisit and EndVisit for each node being visited.\n " + "</summary>"; td.Comments.Add(new CodeCommentStatement(comment, true)); comment = "<remarks>\n " + "base.Visit(node, data) calls this.TrackedVisit(node, data), so if\n " + "you want to visit child nodes using the default visiting behaviour,\n " + "use base.TrackedVisit(parentNode, data).\n " + "</remarks>"; td.Comments.Add(new CodeCommentStatement(comment, true)); EasyMethod m = td.AddMethod("BeginVisit"); m.Attributes = MemberAttributes.Family; m.AddParameter(Easy.TypeRef("INode"), "node"); m = td.AddMethod("EndVisit"); m.Attributes = MemberAttributes.Family; m.AddParameter(Easy.TypeRef("INode"), "node"); foreach (Type type in nodeTypes) { if (!type.IsAbstract) { m = td.AddMethod(typeof(object), VisitPrefix + type.Name); m.Attributes = MemberAttributes.Public | MemberAttributes.Override; m.AddParameter(ConvertType(type), GetFieldName(type.Name)); m.AddParameter(new CodeTypeReference(typeof(object)), "data"); CodeExpression var = Easy.Var(GetFieldName(type.Name)); m.Body.InvokeMethod(Easy.This, "BeginVisit", var); m.Body.DeclareVariable(typeof(object), "result").InitExpression = Easy.This.InvokeMethod("TrackedVisit" + type.Name, var, Easy.Var("data")); m.Body.InvokeMethod(Easy.This, "EndVisit", var); m.Body.Return(Easy.Var("result")); } } foreach (Type type in nodeTypes) { if (!type.IsAbstract) { m = td.AddMethod(typeof(object), "TrackedVisit" + type.Name); m.Attributes = MemberAttributes.Public; m.AddParameter(ConvertType(type), GetFieldName(type.Name)); m.AddParameter(new CodeTypeReference(typeof(object)), "data"); m.Body.Return(Easy.Base.InvokeMethod(VisitPrefix + type.Name, Easy.Var(GetFieldName(type.Name)), Easy.Var("data"))); } } return(td); }
static CodeTypeDeclaration CreateAstVisitorClass(List <Type> nodeTypes, bool transformer) { CodeTypeDeclaration td = new CodeTypeDeclaration(transformer ? "AbstractAstTransformer" : "AbstractAstVisitor"); td.TypeAttributes = TypeAttributes.Public | TypeAttributes.Abstract; td.BaseTypes.Add(new CodeTypeReference("IAstVisitor")); if (transformer) { string comment = "The AbstractAstTransformer will iterate through the whole AST,\n " + "just like the AbstractAstVisitor. However, the AbstractAstTransformer allows\n " + "you to modify the AST at the same time: It does not use 'foreach' internally,\n " + "so you can add members to collections of parents of the current node (but\n " + "you cannot insert or delete items as that will make the index used invalid).\n " + "You can use the methods ReplaceCurrentNode and RemoveCurrentNode to replace\n " + "or remove the current node, totally independent from the type of the parent node."; Easy.AddSummary(td, comment); CodeMemberField field = td.AddField(Easy.TypeRef("Stack", "INode"), "nodeStack"); field.InitExpression = Easy.New(field.Type); /* * CodeExpression nodeStack = Easy.Var("nodeStack"); * CodeMemberProperty p = new CodeMemberProperty(); * p.Name = "CurrentNode"; * p.Type = new CodeTypeReference("INode"); * p.Attributes = MemberAttributes.Public | MemberAttributes.Final; * p.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("currentNode"))); * p.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("currentNode"), * new CodePropertySetValueReferenceExpression())); * td.Members.Add(p); */ EasyMethod m = td.AddMethod("ReplaceCurrentNode"); m.AddParameter(Easy.TypeRef("INode"), "newNode"); m.Statements.Add(Easy.Var("nodeStack").InvokeMethod("Pop")); m.Statements.Add(Easy.Var("nodeStack").InvokeMethod("Push", Easy.Var("newNode"))); m = td.AddMethod("RemoveCurrentNode"); m.Statements.Add(Easy.Var("nodeStack").InvokeMethod("Pop")); m.Statements.Add(Easy.Var("nodeStack").InvokeMethod("Push", Easy.Null)); } foreach (Type type in nodeTypes) { if (!type.IsAbstract) { EasyMethod m = td.AddMethod(typeof(object), VisitPrefix + type.Name); m.Attributes = MemberAttributes.Public; m.AddParameter(ConvertType(type), GetFieldName(type.Name)); m.AddParameter(typeof(object), "data"); List <CodeStatement> assertions = new List <CodeStatement>(); string varVariableName = GetFieldName(type.Name); CodeExpression var = Easy.Var(varVariableName); assertions.Add(AssertIsNotNull(var)); AddFieldVisitCode(m, type, var, assertions, transformer); if (type.GetCustomAttributes(typeof(HasChildrenAttribute), true).Length > 0) { if (transformer) { m.Statements.Add(new CodeSnippetStatement(CreateTransformerLoop(varVariableName + ".Children", "INode"))); m.Body.Return(Easy.Null); } else { m.Body.Return(var.InvokeMethod("AcceptChildren", Easy.This, Easy.Var("data"))); } } else { CodeExpressionStatement lastStatement = null; if (m.Statements.Count > 0) { lastStatement = m.Statements[m.Statements.Count - 1] as CodeExpressionStatement; } if (lastStatement != null) { m.Statements.RemoveAt(m.Statements.Count - 1); m.Body.Return(lastStatement.Expression); } else { m.Body.Return(Easy.Null); } } for (int i = 0; i < assertions.Count; i++) { m.Statements.Insert(i, assertions[i]); } } } return(td); }
static CodeTypeDeclaration CreateAstComparisonVisitorClass(List <Type> nodeTypes) { CodeTypeDeclaration td = new CodeTypeDeclaration("AstComparisonVisitor"); td.TypeAttributes = TypeAttributes.Public; td.IsPartial = true; //td.BaseTypes.Add(new CodeTypeReference("IAstVisitor")); foreach (Type type in nodeTypes) { if (!type.IsAbstract) { EasyMethod m = td.AddMethod(typeof(bool), VisitPrefix + type.Name); m.Attributes = MemberAttributes.Public; m.AddParameter(ConvertType(type), GetFieldName(type.Name)); const string right_hand_side_name = "d"; m.AddParameter(typeof(object), right_hand_side_name); List <CodeStatement> assertions = new List <CodeStatement>(); string varVariableName = GetFieldName(type.Name); CodeExpression var = Easy.Var(varVariableName); assertions.Add(IfNullSetFailure(var)); if (varVariableName == "using") { varVariableName = "@using"; } CodeExpression r_var = Easy.Var(right_hand_side_name); assertions.Add(IfNullSetFailure(r_var)); // Confirm their types are the same. m.Statements.Add(new CodeSnippetStatement("\t\t\tif(" + varVariableName + ".GetType() != " + right_hand_side_name + ".GetType()) {return SetFailure();}")); // Cast the object parameter to whatever the other parameter is, and call the variable 'data'. // Like so: AddHandlerStatement data = (AddHandlerStatement) d; m.Statements.Add(new CodeSnippetStatement("\t\t\tvar data = (" + ConvertType(type).BaseType + ")d;")); m.Statements.Add(new CodeConditionStatement(new CodeSnippetExpression("!IsMatch(" + varVariableName + ", data)"), new CodeSnippetStatement("\t\t\t\treturn SetFailure();"))); AddFieldVisitCode(m, type, var, assertions, false); if (type.GetCustomAttributes(typeof(HasChildrenAttribute), true).Length > 0) { m.Body.Return(var.InvokeMethod("AcceptChildren", Easy.This, Easy.Var(right_hand_side_name))); } else { CodeExpressionStatement lastStatement = null; if (m.Statements.Count > 0) { lastStatement = m.Statements[m.Statements.Count - 1] as CodeExpressionStatement; } if (lastStatement != null) { m.Statements.RemoveAt(m.Statements.Count - 1); m.Body.Return(lastStatement.Expression); } else { m.Body.Return(new CodeSnippetExpression("true")); } } for (int i = 0; i < assertions.Count; i++) { m.Statements.Insert(i, assertions[i]); } } } return(td); }
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))); } }