protected override void Emit(CodeTypeDeclaration ctd) { EmitEmptyCtor (ctd); // Parameter fields foreach (string name in sparams.Keys) EmitParameter (ctd, name); // ApplyDefaults EmitApplyDefaults (ctd); // Apply prologue CodeParameterDeclarationExpression p1 = new CodeParameterDeclarationExpression (ProjBuilder, "proj"); CodeParameterDeclarationExpression p2 = new CodeParameterDeclarationExpression (CDH.String, "declloc"); CodeParameterDeclarationExpression p3 = new CodeParameterDeclarationExpression (CDH.ILog, "log"); CodeMemberMethod apply = new CodeMemberMethod (); apply.Name = "Apply"; apply.Attributes = MemberAttributes.Public | MemberAttributes.Override; apply.ReturnType = CDH.Bool; apply.Parameters.Add (p1); apply.Parameters.Add (p2); apply.Parameters.Add (p3); CDH.EmitBaseChainBool (apply); // Elements if (elts.Count > 0) { apply.Statements.Add (CDH.Variable (ProvBuilder, "pb")); apply.Statements.Add (CDH.Variable (TargBuilder, "tb")); CodeArgumentReferenceExpression proj = CDH.ARef ("proj"); CodeArgumentReferenceExpression declloc = CDH.ARef ("declloc"); CodeArgumentReferenceExpression log = CDH.ARef ("log"); CodeVariableReferenceExpression pb = CDH.VRef ("pb"); CodeVariableReferenceExpression tb = CDH.VRef ("tb"); foreach (StructureElement se in elts) se.EmitApply (apply, proj, declloc, log, pb, tb); } // Apply epilogue apply.Statements.Add (new CodeMethodReturnStatement (CDH.False)); ctd.Members.Add (apply); }
protected CodeConstructor EmitTemplate(CodeTypeDeclaration ctd) { EmitAttribute(ctd); // A(n optional) field pointing to our bound structure if (UsesStructure) { CodeMemberField f = new CodeMemberField(); f.Name = "stmpl"; f.Attributes = MemberAttributes.Private; f.Type = NS.ParamsType.AsCodeDom; ctd.Members.Add(f); } // The template apply method. CodeMemberMethod meth = new CodeMemberMethod(); meth.Name = "ApplyTemplate"; meth.Attributes = MemberAttributes.Public | MemberAttributes.Override; meth.ReturnType = null; meth.Parameters.Add(CDH.Param(typeof(TargetBuilder), "tb")); CDH.EmitBaseChainVoid(meth); CodeVariableReferenceExpression tb = CDH.VRef("tb"); if (UsesStructure) { info.Converter = delegate(string val) { return(NS.MakeTargetNameExpr(val, CDH.ThisDot("stmpl"), null)); }; } info.EmitInfo(meth, tb); ctd.Members.Add(meth); // Constructor return(EmitConstructor(ctd)); }
void EmitBuildWrapped(CodeTypeDeclaration cur_type, CodeMemberMethod meth) { CodeMethodInvokeExpression inv = new CodeMethodInvokeExpression(CDH.This, "CreateResultObject", new CodeExpression[0] { }); CodeCastExpression cast = new CodeCastExpression(bf_ret_class.AsCodeDom, inv); CodeVariableDeclarationStatement vd = new CodeVariableDeclarationStatement(bf_ret_class.AsCodeDom, bf_ret_arg, cast); meth.Statements.Add(vd); CodeVariableReferenceExpression r1 = CDH.VRef(bf_ret_arg); CodeVariableReferenceExpression r2 = CDH.VRef(bf_context_arg); inv = new CodeMethodInvokeExpression(CDH.This, "BuildImpl", new CodeExpression[2] { r1, r2 }); meth.Statements.Add(CDH.IfTrueReturnNull(inv)); meth.Statements.Add(new CodeMethodReturnStatement(r1)); // BuildImpl CodeParameterDeclarationExpression p1 = CDH.Param(bf_ret_class.AsCodeDom, bf_ret_arg); CodeParameterDeclarationExpression p2 = CDH.Param(CDH.IContext, bf_context_arg); meth = new CodeMemberMethod(); meth.Name = "BuildImpl"; meth.Attributes = MemberAttributes.Private; meth.ReturnType = CDH.Bool; meth.Parameters.Add(p1); meth.Parameters.Add(p2); meth.Statements.Add(bf_code.AsStatement); cur_type.Members.Add(meth); }
protected override void Emit(CodeTypeDeclaration type) { type.CustomAttributes.Add(new CodeAttributeDeclaration("System.Serializable")); // Initialized constructor CodeFieldReferenceExpression left = CDH.ThisDot("Value"); CodeConstructor ctor = EmitEmptyCtor(type); ctor.Parameters.Add(CDH.Param(etype, "init")); ctor.Statements.Add(new CodeAssignStatement(left, CDH.VRef("init"))); // Default constructor. ctor = EmitEmptyCtor(type); CodeTypeReferenceExpression tre = new CodeTypeReferenceExpression(etype.AsCodeDom); CodeFieldReferenceExpression right = new CodeFieldReferenceExpression(tre, DefaultName); ctor.Statements.Add(new CodeAssignStatement(left, right)); }
void EmitArguments(CodeTypeDeclaration cur_type) { CodeMemberMethod list, fetch, clear; CodeVariableReferenceExpression sink, source; // ListArguments prologue list = new CodeMemberMethod(); list.Name = "ListArguments"; list.Attributes = MemberAttributes.Public | MemberAttributes.Override; list.ReturnType = null; list.Parameters.Add(CDH.Param(ArgInfoSink, "sink")); CDH.EmitBaseChainVoid(list); sink = CDH.VRef("sink"); // FetchArgValues prologue fetch = new CodeMemberMethod(); fetch.Name = "FetchArgValues"; fetch.Attributes = MemberAttributes.Public | MemberAttributes.Override; fetch.ReturnType = null; fetch.Parameters.Add(CDH.Param(ArgValueSource, "source")); CDH.EmitBaseChainVoid(fetch); source = new CodeVariableReferenceExpression("source"); // ClearArgValues prologue clear = new CodeMemberMethod(); clear.Name = "ClearArgValues"; clear.Attributes = MemberAttributes.Public | MemberAttributes.Override; clear.ReturnType = null; CDH.EmitBaseChainVoid(clear); // Per-arg statements if (target_arg_name != null) { EmitTargetArg(list, sink, fetch, source, clear, cur_type); } if (arguments.Count > 0) { list.Statements.Add(BaseNumArgs); fetch.Statements.Add(BaseNumArgs); } for (int i = 0; i < arguments.Count; i++) { arguments[i].EmitStatements(list, sink, fetch, source, clear); arguments[i].EmitField(cur_type); } // No epilogues. cur_type.Members.Add(list); cur_type.Members.Add(fetch); cur_type.Members.Add(clear); // NumArguments property override CodeMemberProperty p = new CodeMemberProperty(); p.Name = "NumArguments"; p.HasGet = true; p.HasSet = false; p.Type = new CodeTypeReference(typeof(int)); p.Attributes = MemberAttributes.Public | MemberAttributes.Override; CodeBinaryOperatorExpression add = new CodeBinaryOperatorExpression(); add.Left = new CodePropertyReferenceExpression(CDH.Base, "NumArguments"); add.Operator = CodeBinaryOperatorType.Add; add.Right = new CodePrimitiveExpression(arguments.Count); p.GetStatements.Add(new CodeMethodReturnStatement(add)); cur_type.Members.Add(p); }
void EmitAsComposite(CodeTypeDeclaration ctd) { if (fields.Count == 0) { return; } if (comp_default_idx >= 0) { EmitDefault(ctd); } // Prologues - TotalItems field CodeMemberProperty ti = new CodeMemberProperty(); ti.Name = "TotalItems"; ti.HasGet = true; ti.HasSet = false; ti.Type = new CodeTypeReference(typeof(int)); ti.Attributes = MemberAttributes.Family | MemberAttributes.Override; CodeBinaryOperatorExpression add = new CodeBinaryOperatorExpression(); add.Left = new CodePropertyReferenceExpression(CDH.Base, "TotalItems"); add.Operator = CodeBinaryOperatorType.Add; add.Right = new CodePrimitiveExpression(fields.Count); CodeStatement ret = new CodeMethodReturnStatement(add); ti.GetStatements.Add(ret); ctd.Members.Add(ti); // Prologues - CopyItems CodeParameterDeclarationExpression p = CDH.Param(new CodeTypeReference(CDH.Result, 1), "r"); CodeMemberMethod copy = new CodeMemberMethod(); copy.Name = "CopyItems"; copy.ReturnType = null; copy.Parameters.Add(p); copy.Attributes = MemberAttributes.Family | MemberAttributes.Override; CDH.EmitBaseChainVoid(copy); CodeExpression copyarray = new CodeArgumentReferenceExpression(p.Name); copy.Statements.Add(BaseTotalItems); // Prologues - CloneTo method p = CDH.Param(CDH.Result, "r"); CodeMemberMethod clone = new CodeMemberMethod(); clone.Name = "CloneTo"; clone.ReturnType = null; clone.Parameters.Add(p); clone.Attributes = MemberAttributes.Family | MemberAttributes.Override; CDH.EmitBaseChainVoid(clone); CodeExpression cp = CDH.ARef(p.Name); CodeVariableDeclarationStatement vds = new CodeVariableDeclarationStatement(); vds.Name = "other"; vds.Type = new CodeTypeReference(ctd.Name); vds.InitExpression = new CodeCastExpression(vds.Type, cp); clone.Statements.Add(vds); CodeExpression other = CDH.VRef(vds.Name); // Now per-field statements foreach (FieldInfo fi in fields) { fi.Emit(ctd, copy, copyarray, clone, other); } // no epilogues. ctd.Members.Add(copy); ctd.Members.Add(clone); }